@embedpdf/core 1.0.10 → 1.0.12

package/dist/lib/store/actions.d.ts

@@ -0,0 +1,39 @@
+import { PdfDocumentObject, PdfPageObject, Rotation } from '@embedpdf/models';
+export declare const LOAD_DOCUMENT = "LOAD_DOCUMENT";
+export declare const SET_DOCUMENT = "SET_DOCUMENT";
+export declare const SET_DOCUMENT_ERROR = "SET_DOCUMENT_ERROR";
+export declare const SET_SCALE = "SET_SCALE";
+export declare const SET_ROTATION = "SET_ROTATION";
+export declare const SET_PAGES = "SET_PAGES";
+export declare const CORE_ACTION_TYPES: readonly ["LOAD_DOCUMENT", "SET_DOCUMENT", "SET_DOCUMENT_ERROR", "SET_SCALE", "SET_ROTATION", "SET_PAGES"];
+export interface LoadDocumentAction {
+    type: typeof LOAD_DOCUMENT;
+}
+export interface SetDocumentAction {
+    type: typeof SET_DOCUMENT;
+    payload: PdfDocumentObject;
+}
+export interface SetDocumentErrorAction {
+    type: typeof SET_DOCUMENT_ERROR;
+    payload: string;
+}
+export interface SetScaleAction {
+    type: typeof SET_SCALE;
+    payload: number;
+}
+export interface SetRotationAction {
+    type: typeof SET_ROTATION;
+    payload: Rotation;
+}
+export interface SetPagesAction {
+    type: typeof SET_PAGES;
+    payload: PdfPageObject[][];
+}
+export type DocumentAction = LoadDocumentAction | SetDocumentAction | SetDocumentErrorAction | SetScaleAction | SetRotationAction | SetPagesAction;
+export type CoreAction = DocumentAction;
+export declare const loadDocument: () => CoreAction;
+export declare const setDocument: (document: PdfDocumentObject) => CoreAction;
+export declare const setDocumentError: (error: string) => CoreAction;
+export declare const setScale: (scale: number) => CoreAction;
+export declare const setRotation: (rotation: Rotation) => CoreAction;
+export declare const setPages: (pages: PdfPageObject[][]) => CoreAction;

package/dist/lib/store/index.d.ts

@@ -0,0 +1,6 @@
+export * from './store';
+export * from './plugin-store';
+export * from './types';
+export * from './initial-state';
+export * from './actions';
+export * from './selectors';

package/dist/lib/store/initial-state.d.ts

@@ -0,0 +1,11 @@
+import { PdfDocumentObject, PdfPageObject, Rotation } from '@embedpdf/models';
+import { PluginRegistryConfig } from '../types/plugin';
+export interface CoreState {
+    scale: number;
+    rotation: Rotation;
+    document: PdfDocumentObject | null;
+    pages: PdfPageObject[][];
+    loading: boolean;
+    error: string | null;
+}
+export declare const initialCoreState: (config?: PluginRegistryConfig) => CoreState;

package/dist/lib/store/plugin-store.d.ts

@@ -0,0 +1,48 @@
+import { Store } from './store';
+import { Action } from './types';
+/**
+ * A type-safe store handle for plugins, providing access to plugin-specific state and actions.
+ */
+export declare class PluginStore<PluginState, PluginAction extends Action> {
+    private store;
+    private pluginId;
+    /**
+     * Initializes the PluginStore with the main store and plugin ID.
+     * @param store The main store instance.
+     * @param pluginId The unique identifier for the plugin.
+     */
+    constructor(store: Store<any, any>, pluginId: string);
+    /**
+     * Gets the current state of the plugin.
+     * @returns The plugin's state.
+     */
+    getState(): PluginState;
+    /**
+     * Dispatches an action for the plugin and returns the *new* global state.
+     * If you only need the plugin’s updated state, call `getState()` afterward.
+     * @param action The action to dispatch.
+     * @returns The updated global store state (after plugin reducer).
+     */
+    dispatch(action: PluginAction): PluginState;
+    /**
+     * Subscribes to state changes only for this specific plugin.
+     * You now receive (action, newPluginState, oldPluginState) in the callback.
+     *
+     * @param listener The callback to invoke when plugin state changes.
+     * @returns A function to unsubscribe the listener.
+     */
+    subscribeToState(listener: (action: PluginAction, newState: PluginState, oldState: PluginState) => void): () => void;
+    /**
+     * Subscribes to a specific action type for the plugin.
+     * This still uses the main store's `onAction`, so you get the *global*
+     * old/new store states there. If you specifically want old/new plugin state,
+     * use `subscribeToState` instead.
+     *
+     * @param type The action type to listen for.
+     * @param handler The callback to invoke when the action occurs.
+     * @returns A function to unsubscribe the handler.
+     */
+    onAction<T extends PluginAction['type']>(type: T, handler: (action: Extract<PluginAction, {
+        type: T;
+    }>, state: PluginState, oldState: PluginState) => void): () => void;
+}

package/dist/lib/store/reducer.d.ts

@@ -0,0 +1,4 @@
+import { Reducer } from './types';
+import { CoreState } from './initial-state';
+import { CoreAction } from './actions';
+export declare const coreReducer: Reducer<CoreState, CoreAction>;

package/dist/lib/store/selectors.d.ts

@@ -0,0 +1,3 @@
+import { CoreState } from './initial-state';
+import { PdfPageObjectWithRotatedSize } from '@embedpdf/models';
+export declare const getPagesWithRotatedSize: (state: CoreState) => PdfPageObjectWithRotatedSize[][];

package/dist/lib/store/store.d.ts

@@ -0,0 +1,105 @@
+import { Reducer, Action, StoreState, StoreListener, PluginListener } from './types';
+import { PluginStore } from './plugin-store';
+/**
+ * A generic, type-safe store class managing core and plugin states, reducers, and subscriptions.
+ * @template CoreState The type of the core state.
+ * @template CoreAction The type of actions handled by core reducers (extends Action).
+ */
+export declare class Store<CoreState, CoreAction extends Action = Action> {
+    initialCoreState: CoreState;
+    private state;
+    private coreReducer;
+    private pluginReducers;
+    private listeners;
+    private pluginListeners;
+    /**
+     * Initializes the store with the provided core state.
+     * @param reducer          The core reducer function
+     * @param initialCoreState The initial core state
+     */
+    constructor(reducer: Reducer<CoreState, CoreAction>, initialCoreState: CoreState);
+    /**
+     * Adds a reducer for a plugin-specific state.
+     * @param pluginId The unique identifier for the plugin.
+     * @param reducer The reducer function for the plugin state.
+     * @param initialState The initial state for the plugin.
+     */
+    addPluginReducer<PluginState>(pluginId: string, reducer: Reducer<PluginState, Action>, initialState: PluginState): void;
+    /**
+     * Dispatches an action *only* to the core reducer.
+     * Notifies the global store listeners with (action, newState, oldState).
+     *
+     * @param action The action to dispatch, typed as CoreAction
+     * @returns The updated *global* store state
+     */
+    dispatchToCore(action: CoreAction): StoreState<CoreState>;
+    /**
+     * Dispatches an action *only* to a specific plugin.
+     * Optionally notifies global store listeners if `notifyGlobal` is true.
+     * Always notifies plugin-specific listeners with (action, newPluginState, oldPluginState).
+     *
+     * @param pluginId   The plugin identifier
+     * @param action     The plugin action to dispatch
+     * @param notifyGlobal Whether to also notify global store listeners
+     * @returns The updated *global* store state
+     */
+    dispatchToPlugin<PluginAction extends Action>(pluginId: string, action: PluginAction, notifyGlobal?: boolean): any;
+    /**
+     * Dispatches an action to update the state using:
+     * - the core reducer (if it's a CoreAction)
+     * - *all* plugin reducers (regardless of action type), with no global notify for each plugin
+     *
+     * Returns the new *global* store state after all reducers have processed the action.
+     *
+     * @param action The action to dispatch (can be CoreAction or any Action).
+     */
+    dispatch(action: CoreAction | Action): StoreState<CoreState>;
+    /**
+     * Returns a shallow copy of the current state.
+     * @returns The current store state.
+     */
+    getState(): StoreState<CoreState>;
+    /**
+     * Subscribes a listener to *global* state changes.
+     * The callback signature is now (action, newState, oldState).
+     *
+     * @param listener The callback to invoke on state changes
+     * @returns A function to unsubscribe the listener
+     */
+    subscribe(listener: StoreListener<CoreState>): () => void;
+    /**
+     * Subscribes a listener to *plugin-specific* state changes.
+     * The callback signature is now (action, newPluginState, oldPluginState).
+     *
+     * @param pluginId The unique identifier for the plugin.
+     * @param listener The callback to invoke on plugin state changes.
+     * @returns A function to unsubscribe the listener.
+     */
+    subscribeToPlugin(pluginId: string, listener: PluginListener): () => void;
+    /**
+     * Subscribes to a specific action type (only from the core's action union).
+     * The callback signature is (action, newState, oldState).
+     *
+     * @param type The action type to listen for.
+     * @param handler The callback to invoke when the action occurs.
+     * @returns A function to unsubscribe the handler.
+     */
+    onAction<T extends CoreAction['type']>(type: T, handler: (action: Extract<CoreAction, {
+        type: T;
+    }>, state: StoreState<CoreState>, oldState: StoreState<CoreState>) => void): () => void;
+    /**
+     * Gets a PluginStore handle for a specific plugin.
+     * @param pluginId The unique identifier for the plugin.
+     * @returns A PluginStore instance for the plugin.
+     */
+    getPluginStore<PluginState, PluginAction extends Action>(pluginId: string): PluginStore<PluginState, PluginAction>;
+    /**
+     * Helper method to check if an action is a CoreAction.
+     * Adjust if you have a more refined way to differentiate CoreAction vs. any other Action.
+     */
+    isCoreAction(action: Action): action is CoreAction;
+    /**
+     * Destroy the store: drop every listener and plugin reducer
+     */
+    destroy(): void;
+}

package/dist/lib/store/types.d.ts

@@ -0,0 +1,28 @@
+/** Represents an action with a type and optional payload */
+export interface Action {
+    type: string;
+    payload?: any;
+}
+/** A reducer function that updates a specific state based on an action */
+export type Reducer<State, Action> = (state: State, action: Action) => State;
+/**
+ * Represents the overall store state, with a typed core and plugin states
+ */
+export interface StoreState<CoreState> {
+    core: CoreState;
+    plugins: Record<string, any>;
+}
+/**
+ * The signature of a main-store listener. You now receive:
+ * - `action`    => The action that was dispatched
+ * - `newState` => The store state *after* the update
+ * - `oldState` => The store state *before* the update
+ */
+export type StoreListener<CoreState> = (action: Action, newState: StoreState<CoreState>, oldState: StoreState<CoreState>) => void;
+/**
+ * The signature of a plugin-store listener. You now receive:
+ * - `action`         => The action that was dispatched
+ * - `newPluginState` => The plugin state *after* the update
+ * - `oldPluginState` => The plugin state *before* the update
+ */
+export type PluginListener = (action: Action, newPluginState: any, oldPluginState: any) => void;

package/dist/lib/types/errors.d.ts

@@ -0,0 +1,21 @@
+export declare class PluginRegistrationError extends Error {
+    constructor(message: string);
+}
+export declare class PluginNotFoundError extends Error {
+    constructor(message: string);
+}
+export declare class CircularDependencyError extends Error {
+    constructor(message: string);
+}
+export declare class CapabilityNotFoundError extends Error {
+    constructor(message: string);
+}
+export declare class CapabilityConflictError extends Error {
+    constructor(message: string);
+}
+export declare class PluginInitializationError extends Error {
+    constructor(message: string);
+}
+export declare class PluginConfigurationError extends Error {
+    constructor(message: string);
+}

package/dist/lib/types/plugin.d.ts

@@ -0,0 +1,49 @@
+import { PluginRegistry } from '../registry/plugin-registry';
+import { PdfEngine, Rotation } from '@embedpdf/models';
+import { Action, Reducer } from '../store/types';
+import { CoreState } from '../store';
+export interface IPlugin<TConfig = unknown> {
+    id: string;
+    initialize?(config: TConfig): Promise<void>;
+    destroy?(): Promise<void> | void;
+    provides?(): any;
+    postInitialize?(): Promise<void>;
+    ready?(): Promise<void>;
+}
+export interface BasePluginConfig {
+    enabled?: boolean;
+}
+export interface PluginRegistryConfig {
+    rotation?: Rotation;
+    scale?: number;
+}
+export interface PluginManifest<TConfig = unknown> {
+    id: string;
+    name: string;
+    version: string;
+    provides: string[];
+    requires: string[];
+    optional: string[];
+    defaultConfig: TConfig;
+    metadata?: {
+        description?: string;
+        author?: string;
+        homepage?: string;
+        [key: string]: unknown;
+    };
+}
+export interface PluginPackage<T extends IPlugin<TConfig>, TConfig = unknown, TState = unknown, TAction extends Action = Action> {
+    manifest: PluginManifest<TConfig>;
+    create(registry: PluginRegistry, engine: PdfEngine, config: TConfig): T;
+    reducer: Reducer<TState, TAction>;
+    initialState: TState | ((coreState: CoreState, config: TConfig) => TState);
+}
+export type PluginStatus = 'registered' | 'active' | 'error' | 'disabled' | 'unregistered';
+export interface PluginBatchRegistration<T extends IPlugin<TConfig>, TConfig = unknown, TState = unknown, TAction extends Action = Action> {
+    package: PluginPackage<T, TConfig, TState, TAction>;
+    config?: Partial<TConfig>;
+}
+export interface GlobalStoreState<TPlugins extends Record<string, any> = {}> {
+    core: CoreState;
+    plugins: TPlugins;
+}

package/dist/lib/utils/dependency-resolver.d.ts

@@ -0,0 +1,6 @@
+export declare class DependencyResolver {
+    private dependencyGraph;
+    addNode(id: string, dependencies?: string[]): void;
+    private hasCircularDependencies;
+    resolveLoadOrder(): string[];
+}

package/dist/lib/utils/event-control.d.ts

@@ -0,0 +1,23 @@
+export type EventHandler<T> = (data: T) => void;
+export interface BaseEventControlOptions {
+    wait: number;
+}
+export interface DebounceOptions extends BaseEventControlOptions {
+    mode: 'debounce';
+}
+export interface ThrottleOptions extends BaseEventControlOptions {
+    mode: 'throttle';
+    throttleMode?: 'leading-trailing' | 'trailing';
+}
+export type EventControlOptions = DebounceOptions | ThrottleOptions;
+export declare class EventControl<T> {
+    private handler;
+    private options;
+    private timeoutId?;
+    private lastRun;
+    constructor(handler: EventHandler<T>, options: EventControlOptions);
+    handle: (data: T) => void;
+    private debounce;
+    private throttle;
+    destroy(): void;
+}

package/dist/lib/utils/eventing.d.ts

@@ -0,0 +1,19 @@
+import { EventControlOptions } from './event-control';
+export type Listener<T = any> = (value: T) => void;
+export type Unsubscribe = () => void;
+export type EventListener<T> = ((listener: Listener<T>) => Unsubscribe) | ((listener: Listener<T>, options?: EventControlOptions) => Unsubscribe);
+export type EventHook<T = any> = EventListener<T>;
+export interface Emitter<T = any> {
+    emit(value?: T): void;
+    on(listener: Listener<T>): Unsubscribe;
+    off(listener: Listener<T>): void;
+    clear(): void;
+}
+export declare function createEmitter<T = any>(): Emitter<T>;
+export interface BehaviorEmitter<T = any> extends Omit<Emitter<T>, 'on' | 'off'> {
+    readonly value?: T;
+    on: EventHook<T>;
+    off(listener: Listener<T>): void;
+    select<U>(selector: (v: T) => U, equality?: (a: U, b: U) => boolean): EventHook<U>;
+}
+export declare function createBehaviorEmitter<T = any>(initial?: T, equality?: (a: T, b: T) => boolean): BehaviorEmitter<T>;

package/dist/lib/utils/math.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Restrict a numeric value to the inclusive range [min, max].
+ *
+ * @example
+ *   clamp( 5, 0, 10)  // 5
+ *   clamp(-3, 0, 10)  // 0
+ *   clamp(17, 0, 10)  // 10
+ */
+export declare function clamp(value: number, min: number, max: number): number;
+/**
+ * Deeply compares two values (objects, arrays, primitives)
+ * with the following rules:
+ *  - Objects are compared ignoring property order.
+ *  - Arrays are compared ignoring element order (multiset comparison).
+ *  - Primitives are compared by strict equality.
+ *  - null/undefined are treated as normal primitives.
+ *
+ * @param a First value
+ * @param b Second value
+ * @param visited Used internally to detect cycles
+ */
+export declare function arePropsEqual(a: any, b: any, visited?: Set<any>): boolean;

package/dist/lib/utils/plugin-helpers.d.ts

@@ -0,0 +1,6 @@
+import { Action } from '../store';
+import { IPlugin, PluginBatchRegistration, PluginPackage } from '../types/plugin';
+/**
+ * Helper function to create a properly typed plugin registration
+ */
+export declare function createPluginRegistration<T extends IPlugin<TConfig>, TConfig, TState, TAction extends Action>(pluginPackage: PluginPackage<T, TConfig, TState, TAction>, config?: Partial<TConfig>): PluginBatchRegistration<T, TConfig, any, any>;

package/dist/lib/utils/typed-object.d.ts

@@ -0,0 +1,12 @@
+type EnumKey = string | number;
+/**
+ * Iterate over a Record whose keys are enum members (numeric or string),
+ * getting back a fully-typed `[key, value]` tuple array.
+ *
+ * Usage:
+ *   for (const [subtype, defaults] of enumEntries(this.state.toolDefaults)) {
+ *     // subtype is inferred as keyof ToolDefaultsBySubtype
+ *   }
+ */
+export declare function enumEntries<E extends EnumKey, V>(record: Record<E, V>): Array<[E, V]>;
+export {};

package/dist/preact/adapter.d.ts

@@ -0,0 +1,4 @@
+import { createContext } from 'preact';
+export { useEffect, useRef, useState, useCallback, useMemo, useContext } from 'preact/hooks';
+export type { ComponentChildren as ReactNode, JSX } from 'preact';
+export { createContext };

package/dist/preact/index.cjs

@@ -1,188 +1,2 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/preact/index.ts
-var preact_exports = {};
-__export(preact_exports, {
-  EmbedPDF: () => EmbedPDF,
-  PDFContext: () => PDFContext,
-  useCapability: () => useCapability,
-  useCoreState: () => useCoreState,
-  usePlugin: () => usePlugin,
-  useRegistry: () => useRegistry,
-  useStoreState: () => useStoreState
-});
-module.exports = __toCommonJS(preact_exports);
-
-// src/preact/context.ts
-var import_preact = require("preact");
-var PDFContext = (0, import_preact.createContext)({
-  registry: null,
-  isInitializing: true,
-  pluginsReady: false
-});
-
-// src/preact/components/embed-pdf.tsx
-var import_hooks = require("preact/hooks");
-var import_core = require("@embedpdf/core");
-var import_jsx_runtime = require("preact/jsx-runtime");
-function EmbedPDF({ engine, onInitialized, plugins, children }) {
-  const [registry, setRegistry] = (0, import_hooks.useState)(null);
-  const [isInitializing, setIsInitializing] = (0, import_hooks.useState)(true);
-  const [pluginsReady, setPluginsReady] = (0, import_hooks.useState)(false);
-  const initRef = (0, import_hooks.useRef)(onInitialized);
-  (0, import_hooks.useEffect)(() => {
-    initRef.current = onInitialized;
-  }, [onInitialized]);
-  (0, import_hooks.useEffect)(() => {
-    const pdfViewer = new import_core.PluginRegistry(engine);
-    pdfViewer.registerPluginBatch(plugins);
-    const initialize = async () => {
-      await pdfViewer.initialize();
-      if (pdfViewer.isDestroyed()) {
-        return;
-      }
-      await initRef.current?.(pdfViewer);
-      if (pdfViewer.isDestroyed()) {
-        return;
-      }
-      pdfViewer.pluginsReady().then(() => {
-        if (!pdfViewer.isDestroyed()) {
-          setPluginsReady(true);
-        }
-      });
-      setRegistry(pdfViewer);
-      setIsInitializing(false);
-    };
-    initialize().catch(console.error);
-    return () => {
-      pdfViewer.destroy();
-      setRegistry(null);
-      setIsInitializing(true);
-      setPluginsReady(false);
-    };
-  }, [engine, plugins]);
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PDFContext.Provider, { value: { registry, isInitializing, pluginsReady }, children: typeof children === "function" ? children({ registry, isInitializing, pluginsReady }) : children });
-}
-
-// src/preact/hooks/use-registry.ts
-var import_hooks2 = require("preact/hooks");
-function useRegistry() {
-  const contextValue = (0, import_hooks2.useContext)(PDFContext);
-  if (contextValue === void 0) {
-    throw new Error("useCapability must be used within a PDFContext.Provider");
-  }
-  const { registry, isInitializing } = contextValue;
-  if (isInitializing) {
-    return contextValue;
-  }
-  if (registry === null) {
-    throw new Error("PDF registry failed to initialize properly");
-  }
-  return contextValue;
-}
-
-// src/preact/hooks/use-plugin.ts
-function usePlugin(pluginId) {
-  const { registry } = useRegistry();
-  if (registry === null) {
-    return {
-      plugin: null,
-      isLoading: true,
-      ready: new Promise(() => {
-      })
-    };
-  }
-  const plugin = registry.getPlugin(pluginId);
-  if (!plugin) {
-    throw new Error(`Plugin ${pluginId} not found`);
-  }
-  return {
-    plugin,
-    isLoading: false,
-    ready: plugin.ready()
-  };
-}
-
-// src/preact/hooks/use-capability.ts
-function useCapability(pluginId) {
-  const { plugin, isLoading, ready } = usePlugin(pluginId);
-  if (!plugin) {
-    return {
-      provides: null,
-      isLoading,
-      ready
-    };
-  }
-  if (!plugin.provides) {
-    throw new Error(`Plugin ${pluginId} does not provide a capability`);
-  }
-  return {
-    provides: plugin.provides(),
-    isLoading,
-    ready
-  };
-}
-
-// src/preact/hooks/use-store-state.ts
-var import_hooks3 = require("preact/hooks");
-function useStoreState() {
-  const { registry } = useRegistry();
-  const [state, setState] = (0, import_hooks3.useState)(null);
-  (0, import_hooks3.useEffect)(() => {
-    if (!registry) return;
-    setState(registry.getStore().getState());
-    const unsubscribe = registry.getStore().subscribe((_action, newState) => {
-      setState(newState);
-    });
-    return () => unsubscribe();
-  }, [registry]);
-  return state;
-}
-
-// src/preact/hooks/use-core-state.ts
-var import_hooks4 = require("preact/hooks");
-var import_core2 = require("@embedpdf/core");
-function useCoreState() {
-  const { registry } = useRegistry();
-  const [coreState, setCoreState] = (0, import_hooks4.useState)(null);
-  (0, import_hooks4.useEffect)(() => {
-    if (!registry) return;
-    const store = registry.getStore();
-    setCoreState(store.getState().core);
-    const unsubscribe = store.subscribe((action, newState, oldState) => {
-      if (store.isCoreAction(action) && !(0, import_core2.arePropsEqual)(newState.core, oldState.core)) {
-        setCoreState(newState.core);
-      }
-    });
-    return () => unsubscribe();
-  }, [registry]);
-  return coreState;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  EmbedPDF,
-  PDFContext,
-  useCapability,
-  useCoreState,
-  usePlugin,
-  useRegistry,
-  useStoreState
-});
-//# sourceMappingURL=index.cjs.map
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("preact"),r=require("preact/hooks"),t=require("preact/jsx-runtime"),i=require("@embedpdf/core"),n=e.createContext({registry:null,isInitializing:!0,pluginsReady:!1});function s(){const e=r.useContext(n);if(void 0===e)throw new Error("useCapability must be used within a PDFContext.Provider");const{registry:t,isInitializing:i}=e;if(i)return e;if(null===t)throw new Error("PDF registry failed to initialize properly");return e}function o(e){const{registry:r}=s();if(null===r)return{plugin:null,isLoading:!0,ready:new Promise((()=>{}))};const t=r.getPlugin(e);if(!t)throw new Error(`Plugin ${e} not found`);return{plugin:t,isLoading:!1,ready:t.ready()}}exports.EmbedPDF=function({engine:e,onInitialized:s,plugins:o,children:u}){const[a,l]=r.useState(null),[c,g]=r.useState(!0),[d,p]=r.useState(!1),y=r.useRef(s);return r.useEffect((()=>{y.current=s}),[s]),r.useEffect((()=>{const r=new i.PluginRegistry(e);r.registerPluginBatch(o);return(async()=>{var e;await r.initialize(),r.isDestroyed()||(await(null==(e=y.current)?void 0:e.call(y,r)),r.isDestroyed()||(r.pluginsReady().then((()=>{r.isDestroyed()||p(!0)})),l(r),g(!1)))})().catch(console.error),()=>{r.destroy(),l(null),g(!0),p(!1)}}),[e,o]),t.jsx(n.Provider,{value:{registry:a,isInitializing:c,pluginsReady:d},children:"function"==typeof u?u({registry:a,isInitializing:c,pluginsReady:d}):u})},exports.PDFContext=n,exports.useCapability=function(e){const{plugin:r,isLoading:t,ready:i}=o(e);if(!r)return{provides:null,isLoading:t,ready:i};if(!r.provides)throw new Error(`Plugin ${e} does not provide a capability`);return{provides:r.provides(),isLoading:t,ready:i}},exports.useCoreState=function(){const{registry:e}=s(),[t,n]=r.useState(null);return r.useEffect((()=>{if(!e)return;const r=e.getStore();n(r.getState().core);const t=r.subscribe(((e,t,s)=>{r.isCoreAction(e)&&!i.arePropsEqual(t.core,s.core)&&n(t.core)}));return()=>t()}),[e]),t},exports.usePlugin=o,exports.useRegistry=s,exports.useStoreState=function(){const{registry:e}=s(),[t,i]=r.useState(null);return r.useEffect((()=>{if(!e)return;i(e.getStore().getState());const r=e.getStore().subscribe(((e,r)=>{i(r)}));return()=>r()}),[e]),t};
+//# sourceMappingURL=index.cjs.map