import { extractPDFText } from '@localmode/pdfjs';

// From file input
const file = document.getElementById('fileInput').files[0];

const { text, pageCount, metadata } = await extractPDFText(file);

console.log(`Extracted ${pageCount} pages`);
console.log('Title:', metadata?.title);
console.log('Text:', text);

import { extractPDFText } from '@localmode/pdfjs';

const result = await extractPDFText(source, {
  maxPages: 10, // Limit pages to extract
  includePageNumbers: true, // Add [Page N] headers
  pageSeparator: '\n---\n', // Separator between pages
  password: 'secret', // For encrypted PDFs
});

console.log(result.text); // Full extracted text
console.log(result.pageCount); // Total number of pages
console.log(result.pages); // Array of { pageNumber, text } objects
console.log(result.metadata); // PDF metadata
console.log(result.metadataError); // Set only if the metadata could not be read

import { PDFLoader } from '@localmode/pdfjs';

const loader = new PDFLoader({
  splitByPage: false, // Single doc or one per page
  maxPages: undefined, // All pages
  includePageNumbers: true,
  password: undefined,
});

// load() returns LoadedDocument[] ({ id, text, metadata })
const documents = await loader.load(pdfBlob);

for (const doc of documents) {
  console.log(doc.text);
  console.log(doc.metadata);
}

import { PDFLoader } from '@localmode/pdfjs';

const loader = new PDFLoader({ splitByPage: true });
const documents = await loader.load(pdfBlob);

console.log(`Loaded ${documents.length} pages`);

for (const doc of documents) {
  // metadata.page and metadata.totalPages are set when splitByPage is true
  console.log(`Page ${doc.metadata.page}: ${doc.text.substring(0, 100)}...`);
}

import { getPDFPageCount, isPDF } from '@localmode/pdfjs';

// Get page count without full extraction
const pageCount = await getPDFPageCount(pdfBlob);
console.log(`PDF has ${pageCount} pages`);

// Check if file is a PDF
if (await isPDF(file)) {
  // Process as PDF
} else {
  // Handle other file types
}

import { PDFLoader } from '@localmode/pdfjs';
import { createVectorDB, ingest, semanticSearch, streamText } from '@localmode/core';
import { transformers } from '@localmode/transformers';
import { webllm } from '@localmode/webllm';

// Setup
const embeddingModel = transformers.embedding('Xenova/bge-small-en-v1.5');
const llm = webllm.languageModel('Llama-3.2-1B-Instruct-q4f16_1-MLC');
const db = await createVectorDB({ name: 'pdf-docs', dimensions: 384 });

// Load and process PDF
async function ingestPDF(file: File) {
  const loader = new PDFLoader({ splitByPage: true });
  const pages = await loader.load(file);

  // ingest() chunks each page, embeds the chunks, and stores them. Every chunk
  // inherits its page's metadata plus sourceDocId, chunkIndex, chunkStart and
  // chunkEnd, so pass whole pages rather than pre-chunked text.
  const { chunksCreated } = await ingest({
    db,
    model: embeddingModel,
    documents: pages.map((page) => ({
      id: page.id,
      text: page.text,
      metadata: { filename: file.name, page: page.metadata.page },
    })),
    chunking: { strategy: 'recursive', size: 512, overlap: 50 },
  });

  return chunksCreated;
}

// Query
async function queryPDF(question: string) {
  const { results } = await semanticSearch({
    db,
    model: embeddingModel,
    query: question,
    k: 3,
  });

  const context = results.map((r) => `[Page ${r.metadata?.page}]\n${r.text}`).join('\n\n');

  const result = await streamText({
    model: llm,
    prompt: `Answer based on the PDF content:

${context}

Question: ${question}

Answer:`,
  });

  return result;
}

import { useState } from 'react';
import { extractPDFText } from '@localmode/pdfjs';

function PDFUploader() {
  const [text, setText] = useState('');
  const [loading, setLoading] = useState(false);

  async function handleFile(e: React.ChangeEvent<HTMLInputElement>) {
    const file = e.target.files?.[0];
    if (!file) return;

    setLoading(true);
    try {
      const { text, pageCount } = await extractPDFText(file);
      setText(text);
      console.log(`Extracted ${pageCount} pages`);
    } catch (error) {
      console.error('Failed to extract PDF:', error);
    } finally {
      setLoading(false);
    }
  }

  return (
    <div>
      <input type="file" accept=".pdf" onChange={handleFile} />
      {loading && <p>Extracting text...</p>}
      {text && <pre>{text}</pre>}
    </div>
  );
}

import { extractPDFText, getPDFPageCount } from '@localmode/pdfjs';

async function processLargePDF(file: File) {
  const { text, pages, pageCount } = await extractPDFText(file, {
    maxPages: 50, // Limit pages if needed
  });

  console.log(`Processed ${pages.length} of ${pageCount} pages`);

  // Access individual page text
  for (const page of pages) {
    console.log(`Page ${page.pageNumber}: ${page.text.substring(0, 100)}...`);
  }

  return text;
}

import { extractPDFText } from '@localmode/pdfjs';

try {
  const { text } = await extractPDFText(encryptedPDF, {
    password: userProvidedPassword,
  });
  console.log(text);
} catch (error) {
  if (error.message.includes('password')) {
    // Prompt user for password
  }
}

const { metadata, metadataError } = await extractPDFText(file);

if (metadataError) {
  // The information dictionary could not be read; the text is still usable
  console.warn('No metadata:', metadataError);
} else if (metadata) {
  console.log('Title:', metadata.title);
  console.log('Author:', metadata.author);
  console.log('Subject:', metadata.subject);
  console.log('Creator:', metadata.creator);
  console.log('Creation Date:', metadata.creationDate);
  console.log('Modification Date:', metadata.modificationDate);
}