@embedpdf/plugin-ui 1.0.10 → 1.0.12

package/dist/lib/icons/icon-manager.d.ts

@@ -0,0 +1,47 @@
+import { Icon, IconCapabilities, IconIdentifier, IconRegistry } from './types';
+/**
+ * Registry for managing icons throughout the application
+ */
+export declare class IconManager {
+    private icons;
+    constructor(icons: Icon[] | IconRegistry);
+    /**
+     * Register a single icon
+     */
+    registerIcon(icon: Icon): void;
+    /**
+     * Register multiple icons at once
+     */
+    registerIcons(icons: Icon[] | IconRegistry): void;
+    /**
+     * Get all registered icons
+     */
+    getAllIcons(): IconRegistry;
+    /**
+     * Get an icon by its ID
+     */
+    getIcon(id: string): Icon | undefined;
+    /**
+     * Check if an identifier is an SVG string
+     */
+    isSvgString(identifier: IconIdentifier): boolean;
+    /**
+     * Check if a string is an SVG data URI
+     */
+    isSvgDataUri(value: string): boolean;
+    /**
+     * Get the SVG string for an icon identifier
+     * If the identifier is a raw SVG string, it is returned as is
+     * If the identifier is an icon ID, the registered SVG is returned
+     */
+    getSvgString(identifier: IconIdentifier): string | undefined;
+    /**
+     * Utility method to parse a data URI
+     */
+    dataUriToSvgString(dataUri: string): string;
+    /**
+     * Convert an SVG string to a data URI
+     */
+    svgStringToDataUri(svgString: string): string;
+    capabilities(): IconCapabilities;
+}

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

@@ -0,0 +1,36 @@
+/**
+ * Represents an icon in the icon registry
+ */
+export interface Icon {
+    id: string;
+    svg: string;
+}
+/**
+ * Record type for icon registry
+ */
+export type IconRegistry = Record<string, Icon>;
+/**
+ * An identifier for an icon that can be either a registered icon id or raw SVG
+ */
+export type IconIdentifier = string;
+/**
+ * Options for rendering an icon
+ */
+export interface IconRenderOptions {
+    className?: string;
+    title?: string;
+}
+/**
+ * Capabilities for the IconManager
+ */
+export interface IconCapabilities {
+    registerIcon: (icon: Icon) => void;
+    registerIcons: (icons: Icon[] | IconRegistry) => void;
+    getIcon: (id: string) => Icon | undefined;
+    getAllIcons: () => IconRegistry;
+    getSvgString: (identifier: IconIdentifier) => string | undefined;
+    isSvgString: (identifier: IconIdentifier) => boolean;
+    isSvgDataUri: (value: string) => boolean;
+    dataUriToSvgString: (dataUri: string) => string;
+    svgStringToDataUri: (svgString: string) => string;
+}

package/dist/lib/index.d.ts

@@ -0,0 +1,13 @@
+import { PluginPackage } from '@embedpdf/core';
+import { UIPlugin } from './ui-plugin';
+import { UIPluginConfig, UIPluginState } from './types';
+import { UIPluginAction } from './actions';
+export declare const UIPluginPackage: PluginPackage<UIPlugin, UIPluginConfig, UIPluginState, UIPluginAction>;
+export * from './manifest';
+export * from './ui-plugin';
+export * from './types';
+export * from './ui-component';
+export * from './utils';
+export * from './menu/types';
+export * from './icons/types';
+export * from './menu/utils';

package/dist/lib/manifest.d.ts

@@ -0,0 +1,4 @@
+import { PluginManifest } from '@embedpdf/core';
+import { UIPluginConfig } from './types';
+export declare const UI_PLUGIN_ID = "ui";
+export declare const manifest: PluginManifest<UIPluginConfig>;

package/dist/lib/menu/menu-manager.d.ts

@@ -0,0 +1,98 @@
+import { PluginRegistry } from '@embedpdf/core';
+import { MenuItem, ExecuteOptions, ResolvedMenuItem, MenuRegistry, MenuManagerCapabilities, ResolvedMenuItemResult, ResolvedMenu, ResolvedAction } from './types';
+import { EventCallback } from '../utils';
+/**
+ * MenuManager manages a registry of menu items and handles their execution.
+ * It also manages keyboard shortcuts and implements responsive behavior.
+ */
+export declare class MenuManager {
+    private registry;
+    private shortcutMap;
+    private eventController;
+    private pluginRegistry;
+    static readonly EVENTS: {
+        COMMAND_EXECUTED: string;
+        MENU_REQUESTED: string;
+        SHORTCUT_EXECUTED: string;
+    };
+    constructor(items: MenuRegistry | undefined, pluginRegistry: PluginRegistry);
+    /**
+     * Get the current state of the plugin registry
+     */
+    private get state();
+    /**
+     * Register a single menu item
+     */
+    registerItem(item: MenuItem): void;
+    /**
+     * Register multiple menu items at once
+     */
+    registerItems(items: MenuRegistry): void;
+    /**
+     * Resolve a menu item by ID
+     */
+    resolve(id: string): ResolvedMenuItem;
+    /**
+     * Get a menu item by ID with type information
+     */
+    getMenuItem(id: string): ResolvedMenuItemResult | undefined;
+    /**
+     * Get a action by ID (only returns Action type items)
+     */
+    getAction(id: string): ResolvedAction | undefined;
+    /**
+     * Get menu or action by ID
+     */
+    getMenuOrAction(id: string): ResolvedMenu | ResolvedAction | undefined;
+    /**
+     * Get all registered menu items
+     */
+    getAllItems(): MenuRegistry;
+    /**
+     * Get menu items by their IDs
+     */
+    getItemsByIds(ids: string[]): ResolvedMenuItem[];
+    /**
+     * Get child items for a given menu ID
+     * If flatten is true, it will recursively include submenu children but not groups
+     */
+    getChildItems(menuId: string, options?: {
+        flatten?: boolean;
+    }): ResolvedMenuItem[];
+    /**
+     * Execute a command by ID
+     */
+    executeCommand(id: string, options?: ExecuteOptions): void;
+    /**
+     * Execute a command from a keyboard shortcut
+     */
+    executeShortcut(shortcut: string): boolean;
+    /**
+     * Subscribe to menu events
+     */
+    on(eventType: string, callback: EventCallback): () => void;
+    /**
+     * Remove an event subscription
+     */
+    off(eventType: string, callback: EventCallback): void;
+    /**
+     * Handle a menu item that has children (showing a submenu)
+     */
+    private handleSubmenu;
+    /**
+     * Set up keyboard listeners for shortcuts
+     */
+    private setupKeyboardListeners;
+    /**
+     * Convert a KeyboardEvent to a shortcut string
+     */
+    private buildShortcutString;
+    /**
+     * Normalize a shortcut string for consistent comparison
+     */
+    private normalizeShortcut;
+    /**
+     * Get capabilities for the MenuManager
+     */
+    capabilities(): MenuManagerCapabilities;
+}

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

@@ -0,0 +1,83 @@
+import { PluginRegistry } from '@embedpdf/core';
+export type Dynamic<TStore, T> = T | ((state: TStore) => T);
+export interface MenuItemBase<TStore = any> {
+    icon?: Dynamic<TStore, string>;
+    label: Dynamic<TStore, string>;
+    active?: Dynamic<TStore, boolean>;
+    disabled?: Dynamic<TStore, boolean>;
+    shortcut?: string;
+    shortcutLabel?: string;
+    visible?: Dynamic<TStore, boolean>;
+    dividerBefore?: boolean;
+}
+export interface Action<TStore = any> extends MenuItemBase<TStore> {
+    id: string;
+    type: 'action';
+    action: (registry: PluginRegistry, state: TStore) => void;
+}
+export interface Group<TStore = any> {
+    id: string;
+    type: 'group';
+    label: Dynamic<TStore, string>;
+    children: string[];
+}
+export interface Menu<TStore = any> extends MenuItemBase<TStore> {
+    id: string;
+    type: 'menu';
+    children: string[];
+}
+export type MenuItem<TStore = any> = Action<TStore> | Group | Menu<TStore>;
+export type MenuRegistry = Record<string, MenuItem>;
+export interface ExecuteOptions {
+    source?: 'click' | 'shortcut' | 'api';
+    triggerElement?: HTMLElement;
+    flatten?: boolean;
+    position?: 'top' | 'bottom' | 'left' | 'right';
+}
+export declare function hasActive<TStore>(command: MenuItem<TStore>): command is Action<TStore>;
+export interface MenuManagerCapabilities {
+    registerItem: (commandItem: MenuItem) => void;
+    registerItems: (commands: MenuRegistry) => void;
+    executeCommand: (id: string, options?: ExecuteOptions) => void;
+    getAction: (id: string) => ResolvedAction | undefined;
+    getMenuOrAction: (id: string) => ResolvedMenu | ResolvedAction | undefined;
+    getChildItems: (commandId: string, options?: {
+        flatten?: boolean;
+    }) => ResolvedMenuItem[];
+    getItemsByIds: (ids: string[]) => ResolvedMenuItem[];
+    getAllItems: () => MenuRegistry;
+}
+export type Resolved<TStore, T> = T extends Dynamic<TStore, infer U> ? U : T;
+export interface ResolvedMenuItemBase<TStore = any> {
+    icon?: string;
+    label: string;
+    active?: boolean;
+    disabled?: boolean;
+    shortcut?: string;
+    shortcutLabel?: string;
+    visible?: boolean;
+    dividerBefore?: boolean;
+}
+export interface ResolvedAction<TStore = any> extends ResolvedMenuItemBase<TStore> {
+    id: string;
+    type: 'action';
+    action: (registry: PluginRegistry, state: TStore) => void;
+}
+export interface ResolvedGroup<TStore = any> {
+    id: string;
+    type: 'group';
+    label: string;
+    children: string[];
+}
+export interface ResolvedMenu<TStore = any> extends ResolvedMenuItemBase<TStore> {
+    id: string;
+    type: 'menu';
+    children: string[];
+}
+export type ResolvedMenuItem<TStore = any> = ResolvedAction<TStore> | ResolvedGroup<TStore> | ResolvedMenu<TStore>;
+export interface ResolvedMenuItemResult<TStore = any> {
+    item: ResolvedMenuItem<TStore>;
+    isGroup: boolean;
+    isMenu: boolean;
+    isAction: boolean;
+}

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

@@ -0,0 +1,5 @@
+import { MenuItem, ResolvedMenuItem } from './types';
+export declare function resolveMenuItem<TStore>(item: MenuItem<TStore>, state: TStore): ResolvedMenuItem<TStore>;
+export declare function isActive<TStore>(item: MenuItem<TStore>, state: TStore): boolean;
+export declare function isVisible<TStore>(item: MenuItem<TStore>, state: TStore): boolean;
+export declare function isDisabled<TStore>(item: MenuItem<TStore>, state: TStore): boolean;

package/dist/lib/reducer.d.ts

@@ -0,0 +1,5 @@
+import { Reducer } from '@embedpdf/core';
+import { UIPluginState } from './types';
+import { UIPluginAction } from './actions';
+export declare const initialState: UIPluginState;
+export declare const uiReducer: Reducer<UIPluginState, UIPluginAction>;

package/dist/lib/types.d.ts

@@ -0,0 +1,204 @@
+import { CoreState } from '@embedpdf/core';
+import { UI_PLUGIN_ID } from './manifest';
+import { UIComponent } from './ui-component';
+import { MenuRegistry, MenuManagerCapabilities } from './menu/types';
+import { IconRegistry, IconCapabilities } from './icons/types';
+import { SetHeaderVisiblePayload, TogglePanelPayload, UpdateComponentStatePayload } from './actions';
+export interface UIPluginConfig {
+    enabled: boolean;
+    components: Record<string, UIComponentType>;
+    menuItems?: MenuRegistry;
+    icons?: IconRegistry;
+}
+export interface UIPluginState {
+    panel: {
+        [id: string]: PanelState;
+    };
+    header: {
+        [id: string]: HeaderState;
+    };
+    groupedItems: {
+        [id: string]: {};
+    };
+    divider: {
+        [id: string]: {};
+    };
+    iconButton: {
+        [id: string]: {};
+    };
+    tabButton: {
+        [id: string]: {};
+    };
+    selectButton: {
+        [id: string]: {};
+    };
+    custom: {
+        [id: string]: any;
+    };
+    floating: {
+        [id: string]: FloatingState;
+    };
+    commandMenu: {
+        [id: string]: CommandMenuState;
+    };
+}
+export type NavbarPlacement = 'top' | 'bottom' | 'left' | 'right';
+export interface childrenFunctionOptions {
+    context?: Record<string, any>;
+    filter?: (childId: string) => boolean;
+}
+export type UICapability = IconCapabilities & MenuManagerCapabilities & {
+    registerComponentRenderer: (type: string, renderer: (props: any, children: (options?: childrenFunctionOptions) => any[], context?: Record<string, any>) => any) => void;
+    getComponent: <T extends BaseUIComponent<any, any, any>>(id: string) => UIComponent<T> | undefined;
+    getCommandMenu: () => UIComponent<CommandMenuComponent> | undefined;
+    hideCommandMenu: () => void;
+    getHeadersByPlacement: (placement: 'top' | 'bottom' | 'left' | 'right') => UIComponent<HeaderComponent<any>>[];
+    getPanelsByLocation: (location: 'left' | 'right') => UIComponent<PanelComponent<any>>[];
+    getFloatingComponents: (viewportPosition?: 'inside' | 'outside') => UIComponent<FloatingComponent>[];
+    addSlot: (parentId: string, slotId: string, priority?: number) => void;
+    registerComponent: (componentId: string, componentProps: UIComponentType) => UIComponent<any>;
+    togglePanel: (payload: TogglePanelPayload) => void;
+    setHeaderVisible: (payload: SetHeaderVisiblePayload) => void;
+    updateComponentState: <T>(payload: UpdateComponentStatePayload<T>) => void;
+};
+export interface BaseUIComponent<TProps, TInitial = undefined, TStore = any> {
+    id: string;
+    type: string;
+    render?: string;
+    /**
+     * A function that returns a context object for the component's children.
+     */
+    getChildContext?: ((props: TProps) => Record<string, any>) | Record<string, any>;
+    /**
+     * A function that returns a partial set of props from the initial state.
+     */
+    props?: ((init: TInitial) => TProps) | TProps;
+    /**
+     * An object containing the initial state for the component, typed as TInitial.
+     */
+    initialState?: TInitial;
+    /**
+     * A function that, on store changes, returns new or changed props to update
+     * the component with (Redux-like).
+     */
+    mapStateToProps?: (storeState: TStore, ownProps: TProps) => TProps;
+}
+export interface Slot {
+    componentId: string;
+    priority: number;
+    className?: string;
+}
+export interface PanelState {
+    open: boolean;
+    visibleChild: string | null;
+}
+export interface PanelProps {
+    location: 'left' | 'right';
+    open: boolean;
+    visibleChild: string | null;
+    [name: string]: any;
+}
+export interface PanelComponent<TStore = any> extends BaseUIComponent<PanelProps, PanelState, TStore> {
+    type: 'panel';
+    slots: Slot[];
+}
+export interface HeaderState {
+    visible?: boolean;
+    visibleChild?: string | null;
+}
+export interface HeaderProps {
+    placement: 'top' | 'bottom' | 'left' | 'right';
+    style?: Record<string, string>;
+    visible?: boolean;
+    visibleChild?: string | null;
+}
+export interface HeaderComponent<TStore = any> extends BaseUIComponent<HeaderProps, HeaderState, TStore> {
+    type: 'header';
+    slots: Slot[];
+}
+export interface GroupedItemsProps {
+    justifyContent?: 'start' | 'center' | 'end';
+    grow?: number;
+    gap?: number;
+}
+export interface GroupedItemsComponent<TStore = any> extends BaseUIComponent<GroupedItemsProps, undefined, TStore> {
+    type: 'groupedItems';
+    slots: Slot[];
+}
+export interface DividerComponent<TStore = any> extends BaseUIComponent<undefined, undefined, TStore> {
+    type: 'divider';
+}
+export interface IconButtonProps {
+    active?: boolean;
+    disabled?: boolean;
+    commandId?: string;
+    onClick?: () => void;
+    label?: string;
+    img?: string;
+    color?: string;
+}
+export interface IconButtonComponent<TStore = any> extends BaseUIComponent<IconButtonProps, undefined, TStore> {
+    type: 'iconButton';
+}
+export interface TabButtonProps {
+    active?: boolean;
+    commandId?: string;
+    onClick?: () => void;
+    label: string;
+}
+export interface TabButtonComponent<TStore = any> extends BaseUIComponent<TabButtonProps, undefined, TStore> {
+    type: 'tabButton';
+}
+export interface SelectButtonProps {
+    active?: boolean;
+    commandIds: string[];
+    menuCommandId: string;
+    activeCommandId: string;
+}
+export interface SelectButtonComponent<TStore = any> extends BaseUIComponent<SelectButtonProps, undefined, TStore> {
+    type: 'selectButton';
+}
+export interface CustomComponent<TStore = any> extends BaseUIComponent<any, any, TStore> {
+    type: 'custom';
+    render: string;
+    slots?: Slot[];
+}
+export interface FloatingState {
+    [name: string]: any;
+}
+export interface FloatingComponentProps {
+    scrollerPosition: 'inside' | 'outside';
+    [name: string]: any;
+}
+export interface FloatingComponent<TStore = any> extends BaseUIComponent<FloatingComponentProps, FloatingState, TStore> {
+    type: 'floating';
+    slots?: Slot[];
+}
+export interface CommandMenuState {
+    triggerElement?: HTMLElement;
+    activeCommand: string | null;
+    open: boolean;
+    position?: 'top' | 'bottom' | 'left' | 'right';
+    flatten?: boolean;
+}
+export interface CommandMenuProps {
+    triggerElement?: HTMLElement;
+    activeCommand: string | null;
+    open: boolean;
+    position?: 'top' | 'bottom' | 'left' | 'right';
+    flatten?: boolean;
+}
+export interface CommandMenuComponent<TStore = any> extends BaseUIComponent<CommandMenuProps, CommandMenuState, TStore> {
+    type: 'commandMenu';
+}
+export type WithComponentId<TProps> = TProps & {
+    id: string;
+};
+export type ComponentRenderFunction<TProps> = (props: WithComponentId<TProps>, children: (options?: childrenFunctionOptions) => any[], context?: Record<string, any>) => any;
+export interface GlobalStoreState<TPlugins extends Record<string, any> = {}> {
+    core: CoreState;
+    plugins: {
+        [UI_PLUGIN_ID]: UIPluginState;
+    } & TPlugins;
+}
+export type UIComponentType<TStore = any> = GroupedItemsComponent<TStore> | DividerComponent<TStore> | IconButtonComponent<TStore> | TabButtonComponent<TStore> | HeaderComponent<TStore> | PanelComponent<TStore> | CustomComponent<TStore> | FloatingComponent<TStore> | CommandMenuComponent<TStore> | SelectButtonComponent<TStore>;

package/dist/lib/ui-component.d.ts

@@ -0,0 +1,30 @@
+import { BaseUIComponent, childrenFunctionOptions } from './types';
+export declare class UIComponent<T extends BaseUIComponent<any, any, any>> {
+    componentConfig: T;
+    props: T['id'] extends string ? T extends BaseUIComponent<infer P, any, any> ? P & {
+        id: string;
+    } : any : any;
+    type: string;
+    private children;
+    private registry;
+    private updateCallbacks;
+    private hadUpdateBeforeListeners;
+    constructor(componentConfig: T, registry: Record<string, (props: any, children: (options?: childrenFunctionOptions) => any[], context?: Record<string, any>) => any>);
+    addChild(id: string, child: UIComponent<any>, priority?: number, className?: string): void;
+    private sortChildren;
+    removeChild(child: UIComponent<any>): void;
+    clearChildren(): void;
+    get getRenderType(): string;
+    getRenderer(): (props: any, children: (options?: childrenFunctionOptions) => any[], context?: Record<string, any>) => any;
+    getChildren(): {
+        id: string;
+        component: UIComponent<any>;
+        priority: number;
+        className?: string;
+    }[];
+    getChildContext(context: Record<string, any>): Record<string, any>;
+    update(newProps: Partial<T extends BaseUIComponent<infer P, any, any> ? P : any>): void;
+    onUpdate(callback: () => void): boolean;
+    offUpdate(callback: () => void): void;
+    protected notifyUpdate(): void;
+}

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

@@ -0,0 +1,24 @@
+import { BasePlugin, PluginRegistry } from '@embedpdf/core';
+import { UICapability, UIPluginConfig, UIPluginState } from './types';
+import { UIPluginAction } from './actions';
+export declare class UIPlugin extends BasePlugin<UIPluginConfig, UICapability, UIPluginState, UIPluginAction> {
+    static readonly id: "ui";
+    private componentRenderers;
+    private components;
+    private config;
+    private mapStateCallbacks;
+    private globalStoreSubscription;
+    private menuManager;
+    private iconManager;
+    constructor(id: string, registry: PluginRegistry, config: UIPluginConfig);
+    initialize(): Promise<void>;
+    private setupCommandEventHandlers;
+    private addComponent;
+    private buildComponents;
+    private linkGroupedItems;
+    private setInitialStateUIComponents;
+    private onGlobalStoreChange;
+    private addSlot;
+    protected buildCapability(): UICapability;
+    destroy(): Promise<void>;
+}

package/dist/lib/utils.d.ts

@@ -0,0 +1,33 @@
+import { CustomComponent } from './types';
+export declare function defineComponent<TInit, TProps, TStore = any>(): <C extends CustomComponent<TStore> & {
+    initialState: TInit;
+    props: (init: TInit) => TProps;
+    mapStateToProps: (storeState: TStore, ownProps: TProps) => TProps;
+}>(c: C) => C;
+/**
+ * Type definition for event callbacks
+ */
+export type EventCallback = (data: any) => void;
+/**
+ * Interface for the event controller
+ */
+export interface EventController {
+    /**
+     * Emit an event of the specified type with the given data
+     */
+    emit(eventType: string, data: any): void;
+    /**
+     * Subscribe to events of the specified type
+     * Returns a function that can be called to unsubscribe
+     */
+    on(eventType: string, callback: EventCallback): () => void;
+    /**
+     * Unsubscribe a specific callback from events of the specified type
+     */
+    off(eventType: string, callback: EventCallback): void;
+}
+/**
+ * Creates an event controller that manages event subscriptions and dispatching
+ * This is a lightweight pub/sub implementation for typed events
+ */
+export declare function createEventController(): EventController;

package/dist/preact/adapter.d.ts

@@ -0,0 +1,5 @@
+export { Fragment } from 'preact';
+export { useEffect, useRef, useState, useCallback, useMemo } from 'preact/hooks';
+export type { ComponentChildren as ReactNode } from 'preact';
+export type CSSProperties = import('preact').JSX.CSSProperties;
+export type HTMLAttributes<T = any> = import('preact').JSX.HTMLAttributes<T extends EventTarget ? T : never>;

package/dist/preact/core.d.ts

@@ -0,0 +1 @@
+export * from '@embedpdf/core/preact';