@octanejs/pdf 0.0.1

package/src/contexts.ts

@@ -0,0 +1,19 @@
+import { createContext, useContext } from 'octane';
+
+import type { DocumentContextValue, OutlineContextValue, PageContextValue } from './types.js';
+
+export const DocumentContext = createContext<DocumentContextValue | null>(null);
+export const OutlineContext = createContext<OutlineContextValue | null>(null);
+export const PageContext = createContext<PageContextValue | null>(null);
+
+export function useDocumentContext(): DocumentContextValue | null {
+	return useContext(DocumentContext);
+}
+
+export function useOutlineContext(): OutlineContextValue | null {
+	return useContext(OutlineContext);
+}
+
+export function usePageContext(): PageContextValue | null {
+	return useContext(PageContext);
+}

package/src/index.server.ts

@@ -0,0 +1,18 @@
+import * as pdfjs from 'pdfjs-dist/legacy/build/pdf.mjs';
+
+export { Document, Outline, Page, Thumbnail } from './components.tsrx';
+export { useDocumentContext, useOutlineContext, usePageContext } from './contexts.js';
+export { default as PasswordResponses } from './PasswordResponses.js';
+export { pdfjs };
+export type { default as LinkService } from './LinkService.js';
+export type {
+	DocumentProps,
+	OutlineProps,
+	PageProps,
+	PasswordResponsesType,
+	StructTreeNode,
+	TextContent,
+	TextItem,
+	TextMarkedContent,
+	ThumbnailProps,
+} from './types.js';

package/src/index.ts

@@ -0,0 +1,20 @@
+import * as pdfjs from 'pdfjs-dist';
+
+// OCTANE DIVERGENCE[pdf-octane-node-ref-event-types][differential:react-pdf-document-shells]
+// OCTANE DIVERGENCE[pdf-star-export-surface][types:pdf-adapted]
+export { Document, Outline, Page, Thumbnail } from './components.tsrx';
+export { useDocumentContext, useOutlineContext, usePageContext } from './contexts.js';
+export { default as PasswordResponses } from './PasswordResponses.js';
+export { pdfjs };
+export type { default as LinkService } from './LinkService.js';
+export type {
+	DocumentProps,
+	OutlineProps,
+	PageProps,
+	PasswordResponsesType,
+	StructTreeNode,
+	TextContent,
+	TextItem,
+	TextMarkedContent,
+	ThumbnailProps,
+} from './types.js';

package/src/refs.ts

@@ -0,0 +1,14 @@
+import type { OctaneRef } from './types.js';
+
+export function setRef<T>(ref: OctaneRef<T> | undefined, value: T | null): void {
+	if (!ref) return;
+	if (Array.isArray(ref)) {
+		for (const child of ref) setRef(child, value);
+		return;
+	}
+	if (typeof ref === 'function') {
+		ref(value);
+		return;
+	}
+	(ref as { current: T | null }).current = value;
+}

package/src/types.ts

@@ -0,0 +1,205 @@
+import type { PDFDataRangeTransport, PDFDocumentProxy, PDFPageProxy } from 'pdfjs-dist';
+import type { AnnotationLayerParameters } from 'pdfjs-dist/types/src/display/annotation_layer.js';
+import type {
+	DocumentInitParameters,
+	RefProxy,
+	StructTreeNode,
+	TextContent,
+	TextItem,
+	TextMarkedContent,
+	TypedArray,
+} from 'pdfjs-dist/types/src/display/api.js';
+import type { ClassValue, JSX } from 'octane/jsx-runtime';
+
+import type LinkService from './LinkService.js';
+
+export type { StructTreeNode, TextContent, TextItem, TextMarkedContent };
+export type PasswordResponsesType = typeof import('pdfjs-dist').PasswordResponses;
+
+export type OctaneNode = unknown;
+export type OctaneRef<T> =
+	{ current: T | null } | ((value: T | null) => void) | readonly OctaneRef<T>[] | null;
+export type ClassName = ClassValue;
+export type Annotations = NonNullable<AnnotationLayerParameters['annotations']>;
+export type ResolvedDest = (RefProxy | number)[];
+export type Dest = Promise<ResolvedDest> | ResolvedDest | string | null;
+export type ExternalLinkRel = string;
+export type ExternalLinkTarget = '_blank' | '_parent' | '_self' | '_top';
+export type OnItemClickArgs = {
+	dest?: Dest;
+	pageIndex: number;
+	pageNumber: number;
+};
+export type ScrollPageIntoViewArgs = {
+	dest?: ResolvedDest;
+	pageIndex?: number;
+	pageNumber: number;
+};
+export type RenderMode = 'canvas' | 'custom' | 'none';
+type BinaryData = TypedArray | ArrayBuffer | number[] | string;
+export type Source =
+	{ data: BinaryData | undefined } | { range: PDFDataRangeTransport } | { url: string };
+export type File = string | ArrayBuffer | Blob | Source | null;
+type SourceKey = keyof { data: unknown } | keyof { range: unknown } | keyof { url: unknown };
+export type Options = {
+	[K in keyof Omit<DocumentInitParameters, SourceKey>]: DocumentInitParameters[K] | null;
+};
+export type NodeOrRenderer = OctaneNode | (() => OctaneNode);
+export type PageColors = { background: string; foreground: string };
+export type PageCallback = PDFPageProxy & {
+	height: number;
+	originalHeight: number;
+	originalWidth: number;
+	width: number;
+};
+export type CustomRenderer = (props?: Record<string, never>) => OctaneNode;
+export type CustomTextRenderer = (
+	props: { itemIndex: number; pageIndex: number; pageNumber: number } & TextItem,
+) => string;
+export type FilterAnnotations = (args: { annotations: Annotations }) => Annotations;
+
+export interface DocumentContextValue {
+	imageResourcesPath?: string;
+	linkService: LinkService;
+	onItemClick?: (args: OnItemClickArgs) => void;
+	pdf?: PDFDocumentProxy | false;
+	registerPage: (pageIndex: number, ref: HTMLDivElement) => void;
+	renderMode?: RenderMode;
+	rotate?: number | null;
+	scale?: number;
+	unregisterPage: (pageIndex: number) => void;
+}
+
+export interface PageContextValue {
+	page: PDFPageProxy | false | undefined;
+	pageIndex: number;
+	pageNumber: number;
+	rotate: number;
+	scale: number;
+}
+
+export interface OutlineContextValue {
+	onItemClick?: (args: OnItemClickArgs) => void;
+}
+
+export type DocumentRenderProps = Omit<DocumentContextValue, 'pdf'> & { pdf: PDFDocumentProxy };
+export type PageRenderProps = Omit<PageContextValue, 'page'> & { page: PDFPageProxy };
+
+type DivProps = JSX.IntrinsicElements['div'];
+type EventKey = NonNullable<
+	{
+		[Key in keyof DivProps]: Key extends `on${string}` ? Key : never;
+	}[keyof DivProps]
+>;
+type EventProps<Value> = {
+	[Key in EventKey]?: NonNullable<DivProps[Key]> extends (
+		event: infer Event,
+		...args: never[]
+	) => unknown
+		? (event: Event, value: Value) => void
+		: never;
+};
+export type HostProps<Value> = EventProps<Value> & {
+	children?: OctaneNode;
+	class?: ClassName;
+	className?: ClassName;
+	ref?: OctaneRef<unknown>;
+};
+
+export type DocumentProps = HostProps<PDFDocumentProxy | false | undefined> & {
+	children?: OctaneNode | ((props: DocumentRenderProps) => OctaneNode);
+	error?: NodeOrRenderer;
+	externalLinkRel?: ExternalLinkRel;
+	externalLinkTarget?: ExternalLinkTarget;
+	file?: File;
+	imageResourcesPath?: string;
+	inputRef?: OctaneRef<HTMLDivElement>;
+	loading?: NodeOrRenderer;
+	noData?: NodeOrRenderer;
+	onItemClick?: (args: OnItemClickArgs) => void;
+	onLoadError?: (error: Error) => void;
+	onLoadProgress?: (args: { loaded: number; total: number }) => void;
+	onLoadSuccess?: (document: PDFDocumentProxy) => void;
+	onPassword?: (callback: (password: string | null) => void, reason: number) => void;
+	onSourceError?: (error: Error) => void;
+	onSourceSuccess?: () => void;
+	options?: Options;
+	renderMode?: RenderMode;
+	rotate?: number | null;
+	scale?: number;
+};
+
+export type PageProps = HostProps<PageCallback | false | undefined> & {
+	_className?: string;
+	_enableRegisterUnregisterPage?: boolean;
+	canvasBackground?: string;
+	canvasRef?: OctaneRef<HTMLCanvasElement>;
+	children?: OctaneNode | ((props: PageRenderProps) => OctaneNode);
+	customRenderer?: CustomRenderer;
+	customTextRenderer?: CustomTextRenderer;
+	devicePixelRatio?: number;
+	error?: NodeOrRenderer;
+	filterAnnotations?: FilterAnnotations;
+	height?: number;
+	imageResourcesPath?: string;
+	inputRef?: OctaneRef<HTMLDivElement>;
+	loading?: NodeOrRenderer;
+	noData?: NodeOrRenderer;
+	onGetAnnotationsError?: (error: Error) => void;
+	onGetAnnotationsSuccess?: (annotations: Annotations) => void;
+	onGetStructTreeError?: (error: Error) => void;
+	onGetStructTreeSuccess?: (tree: StructTreeNode) => void;
+	onGetTextError?: (error: Error) => void;
+	onGetTextSuccess?: (content: TextContent) => void;
+	onLoadError?: (error: Error) => void;
+	onLoadSuccess?: (page: PageCallback) => void;
+	onRenderAnnotationLayerError?: (error: unknown) => void;
+	onRenderAnnotationLayerSuccess?: () => void;
+	onRenderError?: (error: Error) => void;
+	onRenderSuccess?: (page: PageCallback) => void;
+	onRenderTextLayerError?: (error: Error) => void;
+	onRenderTextLayerSuccess?: () => void;
+	pageColors?: PageColors;
+	pageIndex?: number;
+	pageNumber?: number;
+	pdf?: PDFDocumentProxy | false;
+	registerPage?: (pageIndex: number, ref: HTMLDivElement) => void;
+	renderAnnotationLayer?: boolean;
+	renderForms?: boolean;
+	renderMode?: RenderMode;
+	renderTextLayer?: boolean;
+	rotate?: number | null;
+	scale?: number;
+	unregisterPage?: (pageIndex: number) => void;
+	width?: number;
+};
+
+export type ThumbnailProps = Omit<
+	PageProps,
+	| 'className'
+	| 'customTextRenderer'
+	| 'onGetAnnotationsError'
+	| 'onGetAnnotationsSuccess'
+	| 'onGetTextError'
+	| 'onGetTextSuccess'
+	| 'onRenderAnnotationLayerError'
+	| 'onRenderAnnotationLayerSuccess'
+	| 'onRenderTextLayerError'
+	| 'onRenderTextLayerSuccess'
+	| 'renderAnnotationLayer'
+	| 'renderForms'
+	| 'renderTextLayer'
+> & {
+	className?: ClassName;
+	onItemClick?: (args: OnItemClickArgs) => void;
+};
+
+export type OutlineProps = HostProps<
+	Awaited<ReturnType<PDFDocumentProxy['getOutline']>> | false | undefined
+> & {
+	inputRef?: OctaneRef<HTMLDivElement>;
+	onItemClick?: (args: OnItemClickArgs) => void;
+	onLoadError?: (error: Error) => void;
+	onLoadSuccess?: (outline: Awaited<ReturnType<PDFDocumentProxy['getOutline']>>) => void;
+	pdf?: PDFDocumentProxy | false;
+};

package/src/utils.ts

@@ -0,0 +1,27 @@
+export function isDataURI(value: unknown): value is string {
+	return typeof value === 'string' && /^data:/.test(value);
+}
+
+export function dataURItoByteString(uri: string): string {
+	if (!isDataURI(uri)) throw new Error('Invalid data URI.');
+	const comma = uri.indexOf(',');
+	if (comma < 0) throw new Error('Invalid data URI.');
+	const metadata = uri.slice(0, comma);
+	const payload = uri.slice(comma + 1);
+	return metadata.includes(';base64') ? atob(payload) : decodeURIComponent(payload);
+}
+
+export function dataURItoBytes(uri: string): Uint8Array {
+	return Uint8Array.from(dataURItoByteString(uri), (character) => character.charCodeAt(0));
+}
+
+export function convertDataUriParameterObject<T extends { url: string }>(
+	file: T,
+): Omit<T, 'url'> & { data: Uint8Array } {
+	const { url, ...otherParams } = file;
+	return { data: dataURItoBytes(url), ...otherParams };
+}
+
+export function isProvided<T>(value: T | null | undefined): value is T {
+	return value !== null && value !== undefined;
+}

package/src/vite-env.d.ts

@@ -0,0 +1,4 @@
+declare module '*?url' {
+	const url: string;
+	export default url;
+}

package/upstream-public-surface.json

@@ -0,0 +1,65 @@
+{
+  "authority": {
+    "package": "react-pdf",
+    "version": "10.4.1",
+    "exports": {
+      ".": "./dist/index.js",
+      "./*": "./*"
+    }
+  },
+  "rootRuntimeExports": [
+    "Document",
+    "Outline",
+    "Page",
+    "PasswordResponses",
+    "Thumbnail",
+    "pdfjs",
+    "useDocumentContext",
+    "useOutlineContext",
+    "usePageContext"
+  ],
+  "rootTypeExports": [
+    "DocumentProps",
+    "LinkService",
+    "OutlineProps",
+    "PageProps",
+    "PasswordResponsesType",
+    "StructTreeNode",
+    "TextContent",
+    "TextItem",
+    "TextMarkedContent",
+    "ThumbnailProps"
+  ],
+  "documentedSubpaths": [
+    {
+      "upstream": "react-pdf/dist/Page/AnnotationLayer.css",
+      "octane": "@octanejs/pdf/dist/Page/AnnotationLayer.css",
+      "classification": "exact-public-support"
+    },
+    {
+      "upstream": "react-pdf/dist/Page/TextLayer.css",
+      "octane": "@octanejs/pdf/dist/Page/TextLayer.css",
+      "classification": "exact-public-support"
+    },
+    {
+      "upstream": "pdfjs-dist/build/pdf.worker.min.mjs",
+      "octane": "pdfjs-dist/build/pdf.worker.min.mjs",
+      "classification": "unchanged-framework-neutral-dependency"
+    }
+  ],
+  "wildcardPolicy": {
+    "classification": "framework-private-evidence-only",
+    "reason": "The permissive ./* export exposes React implementation, declarations, tests, and source artifacts that are not documented component entry points. They remain pinned parity evidence. Root exports and the two documented CSS imports are the Octane compatibility contract; direct imports of React implementation files are not remapped.",
+    "artifactRules": [
+      "LICENSE",
+      "README.md",
+      "package.json",
+      "dist/**/*.d.ts",
+      "dist/**/*.js",
+      "src/**/*.css",
+      "src/**/*.ts",
+      "src/**/*.tsx"
+    ],
+    "exactPublicExceptions": ["dist/Page/AnnotationLayer.css", "dist/Page/TextLayer.css"]
+  }
+}