@printstack/print-studio 0.0.0-stage → 0.1.1

package/studio-types.d.ts

@@ -0,0 +1,200 @@
+import { ErrorRuntime } from './components/error-fallback/core';
+import { AlignMode, AlignOptions, DistributeSpacingOptions, SpacingDirection } from './core/align';
+import { DesignerEventMap, TypedEventBus } from './core/events';
+import { RuntimeConfigOptions } from './core/runtime-config';
+import { DataSource, ElementNode, FollowBlock, PageNode, PageTemplate, PrintDocument, RepeatGroup } from './core/types';
+import { PluginManager, PluginPolicy } from './designer/plugins/plugin-manager';
+import { StudioMountOptions } from './designer/types';
+import { HtmlParseOptions, PdfParseOptions, RenderExecutionOptions } from './parser';
+import { RenderExecution } from './parser/render-runtime';
+import { BrowserOutputOptions, PreviewHandle } from './runtime/browser-output';
+import { RegistryOptions } from './runtime/registries';
+export type { StudioMountOptions };
+export type PreviewOptions = BrowserOutputOptions;
+export interface DocumentStorage {
+    get(): null | string;
+    set(document: string): void;
+}
+export interface PreferenceStorage {
+    get(key: string): null | string;
+    set(key: string, value: string): void;
+}
+export interface PrintStudioOptions extends RegistryOptions, RuntimeConfigOptions {
+    createDocument?: () => PrintDocument;
+    defaultElementType?: string;
+    errors?: ErrorRuntime;
+    initialDocument?: PrintDocument;
+    onSave?: (document: PrintDocument) => Promise<void>;
+    persistPreferences?: boolean;
+    pluginPolicy?: PluginPolicy;
+    preferenceStorage?: PreferenceStorage;
+    storage?: DocumentStorage | false;
+    strictInitialDocument?: boolean;
+}
+export type EntityReference = string | {
+    readonly id: string;
+};
+export type ElementOptions = Partial<ElementNode>;
+export type ElementPatch = Partial<Omit<ElementNode, 'id' | 'type'>>;
+export interface MutationOptions {
+    transient?: boolean;
+}
+export type PagePatch = Partial<Pick<PageNode, 'background' | 'height' | 'margins' | 'name' | 'templateId' | 'width'>>;
+export type PageOptions = PagePatch & {
+    id?: string;
+};
+export type TemplatePagePatch = Omit<PagePatch, 'templateId'>;
+export type TemplatePatch = Partial<Pick<PageTemplate, 'background' | 'baseTemplateId' | 'evenPages' | 'facingPages' | 'name' | 'oddPages'>>;
+export type RepeatGroupPatch = Partial<Omit<RepeatGroup, 'id' | 'pageId'>>;
+export type FollowBlockPatch = Partial<Pick<FollowBlock, 'gap' | 'name' | 'target'>>;
+export interface EntityHandle<Model, Patch> {
+    readonly data: Model | undefined;
+    readonly id: string;
+    remove(): void;
+    update(patch: Patch): void;
+}
+export interface EntityCollection<Model, Patch> {
+    get(reference: EntityReference): EntityHandle<Model, Patch> | undefined;
+    readonly list: EntityHandle<Model, Patch>[];
+    remove(reference: EntityReference): void;
+    update(reference: EntityReference, patch: Patch): void;
+}
+export interface ElementsFacade extends EntityCollection<ElementNode, ElementPatch> {
+    add(options?: ElementOptions): EntityHandle<ElementNode, ElementPatch>;
+    clear(): void;
+    duplicate(reference: EntityReference): (EntityHandle<ElementNode, ElementPatch> | undefined)[];
+    move(reference: EntityReference, displayIndex: number): void;
+    rename(reference: EntityReference, name: string): void;
+    toggleFlag(reference: EntityReference, flag: 'locked' | 'visible'): void;
+    update(reference: EntityReference, patch: ElementPatch, options?: MutationOptions): void;
+    updateProps(reference: EntityReference, patch: Record<string, unknown>, options?: MutationOptions): void;
+}
+export interface PageHandle extends EntityHandle<PageNode, PagePatch> {
+    readonly elements: ElementsFacade;
+}
+export interface TemplatePageHandle {
+    readonly data: PageNode | undefined;
+    readonly elements: ElementsFacade;
+    readonly id: string;
+    update(patch: TemplatePagePatch): void;
+}
+export interface TemplateHandle extends EntityHandle<PageTemplate, TemplatePatch> {
+    readonly evenPage: TemplatePageHandle | undefined;
+    readonly page: TemplatePageHandle;
+}
+export interface HtmlResult {
+    execution: RenderExecution;
+    html: string;
+    warnings: string[];
+}
+export interface PdfResult {
+    blob: Blob;
+    execution: RenderExecution;
+    warnings: string[];
+}
+export interface StudioSnapshot {
+    readonly activePageId: string | undefined;
+    readonly canRedo: boolean;
+    readonly canUndo: boolean;
+    readonly dirty: boolean;
+    readonly selectionIds: readonly string[];
+}
+export interface DesignStudio {
+    readonly dataSource: {
+        get(reference: string | {
+            key: string;
+        }): DataSource | undefined;
+        readonly list: DataSource[];
+        remove(reference: string | {
+            key: string;
+        }): void;
+        upsert(source: DataSource, originalKey?: string): void;
+    };
+    dispose(): void;
+    readonly document: {
+        create(): void;
+        readonly data: PrintDocument;
+        readonly dirty: boolean;
+        load(document: PrintDocument): void;
+        loadJson(json: string): void;
+        rename(name: string): void;
+        save(): Promise<void>;
+    };
+    readonly edit: {
+        align(mode: AlignMode, options?: AlignOptions): void;
+        copy(): void;
+        cut(): void;
+        delete(): void;
+        distribute(mode: 'h' | 'v' | AlignMode, options?: AlignOptions): void;
+        distributeSpacing(direction: SpacingDirection, options?: DistributeSpacingOptions): void;
+        duplicate(): void;
+        nudge(dx: number, dy: number): void;
+        paste(): void;
+        reorder(offset: number): void;
+        sendTo(edge: 'back' | 'front'): void;
+    };
+    readonly errors: ErrorRuntime;
+    readonly events: Pick<TypedEventBus<DesignerEventMap>, 'on'>;
+    readonly export: {
+        html(input?: Record<string, unknown>): Promise<HtmlResult>;
+        json(): string;
+        pdf(input?: Record<string, unknown>): Promise<PdfResult>;
+    };
+    readonly followBlock: EntityCollection<FollowBlock, FollowBlockPatch> & {
+        create(options: Partial<Pick<FollowBlock, 'gap' | 'id' | 'name'>> & Pick<FollowBlock, 'elementIds' | 'pageId' | 'target'>): EntityHandle<FollowBlock, FollowBlockPatch> | undefined;
+    };
+    readonly history: {
+        readonly canRedo: boolean;
+        readonly canUndo: boolean;
+        commit(): void;
+        redo(): void;
+        undo(): void;
+    };
+    /** 把可视化设计器挂载到容器；resolve 即界面与插件就绪。一个工作区同时只挂载一个设计器 */
+    mount(options: StudioMountOptions): Promise<void>;
+    readonly page: {
+        readonly active: PageHandle;
+        create(options?: PageOptions): PageHandle;
+        duplicate(reference: EntityReference): PageHandle | undefined;
+        get(reference: EntityReference): PageHandle | undefined;
+        readonly list: PageHandle[];
+        remove(reference: EntityReference): void;
+        setActive(reference: EntityReference): void;
+        update(reference: EntityReference, patch: PagePatch): void;
+    };
+    readonly plugins: Pick<PluginManager, 'disable' | 'dispose' | 'enable' | 'has' | 'install' | 'list' | 'load' | 'status' | 'uninstall'>;
+    preview(input?: Record<string, unknown>, options?: PreviewOptions): Promise<PreviewHandle>;
+    print(input?: Record<string, unknown>, options?: BrowserOutputOptions): Promise<{
+        warnings: string[];
+    }>;
+    readonly repeatGroup: EntityCollection<RepeatGroup, RepeatGroupPatch> & {
+        create(options: Partial<Omit<RepeatGroup, 'elementIds' | 'pageId'>> & Pick<RepeatGroup, 'elementIds' | 'pageId'>): EntityHandle<RepeatGroup, RepeatGroupPatch> | undefined;
+        remove(reference: EntityReference, deleteElements?: boolean): void;
+    };
+    readonly selection: {
+        all(): void;
+        clear(): void;
+        readonly ids: string[];
+        readonly nodes: ElementNode[];
+        set(references: EntityReference[]): void;
+    };
+    readonly state: {
+        getSnapshot(): StudioSnapshot;
+        subscribe(listener: () => void): () => void;
+    };
+    readonly template: {
+        apply(reference: EntityReference, pages: EntityReference[]): void;
+        create(options?: Partial<Pick<PageTemplate, 'id' | 'name'>>): TemplateHandle;
+        detach(reference: EntityReference): void;
+        get(reference: EntityReference): TemplateHandle | undefined;
+        import(source: PageTemplate): TemplateHandle;
+        readonly list: TemplateHandle[];
+        remove(reference: EntityReference): void;
+        update(reference: EntityReference, patch: TemplatePatch): void;
+    };
+    toHTML(input?: Record<string, unknown>, options?: HtmlParseOptions, execution?: RenderExecutionOptions): Promise<HtmlResult>;
+    toPDF(input?: Record<string, unknown>, options?: PdfParseOptions, execution?: RenderExecutionOptions): Promise<PdfResult>;
+    /** 移除已挂载的设计器视图，工作区与文档保留；可重复调用 */
+    unmount(): void;
+    readonly use: PluginManager['use'];
+}

package/studio.d.ts

@@ -0,0 +1,2 @@
+import { DesignStudio, PrintStudioOptions } from './studio-types';
+export declare function createPrintStudio(options?: PrintStudioOptions): DesignStudio;