@g1cloud/page-builder-editor 1.0.0-alpha.1

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { default as PageBuilderEditor } from './PageBuilderEditor.vue';
+export * from './model/event';
+export * from '@g1cloud/page-builder-viewer';

package/dist/model/command.d.ts

@@ -0,0 +1,188 @@
+import { ToolButtonGroup } from './toolbar.ts';
+import { ContextMenu, KeyHandler } from './context.ts';
+import { IPart } from '@g1cloud/page-builder-viewer';
+import { PageBuilderEditor } from './page-builder-editor.ts';
+import { BSModal, MenuItem } from '@g1cloud/bluesea';
+
+export declare const SAVE_MODEL_COMMAND_ID = "SaveModel";
+export interface Command {
+    commandId: string;
+    caption?: string;
+    icon?: string;
+    execute(pageBuilder: PageBuilderEditor, args?: any): void | Promise<void>;
+}
+export interface CommandRegistry {
+    registerCommands(commandList: Command[]): void;
+    registerCommand(command: Command): void;
+    getCommand(commandId: string): Command | undefined;
+    executeCommand(commandId: string, args?: any): boolean;
+}
+export declare class CommandRegistryImpl implements CommandRegistry {
+    private pageBuilder;
+    private commandMap;
+    constructor(pageBuilder: PageBuilderEditor);
+    registerCommands(commandList: Command[]): void;
+    registerCommand(command: Command): void;
+    getCommand(commandId: string): Command | undefined;
+    executeCommand(commandId: string, args?: any): boolean;
+}
+export declare class OpenAddPartModalCommand implements Command {
+    private modal;
+    static readonly COMMAND_ID = "OpenAddPartModal";
+    readonly commandId = "OpenAddPartModal";
+    readonly caption = "Add Part";
+    constructor(modal: BSModal);
+    execute(pageBuilder: PageBuilderEditor, args?: any): void;
+}
+export declare class OpenAddWidgetModalCommand implements Command {
+    private modal;
+    static readonly COMMAND_ID = "OpenAddWidgetModal";
+    readonly commandId = "OpenAddWidgetModal";
+    readonly caption = "Add Block/Widget";
+    constructor(modal: BSModal);
+    execute(pageBuilder: PageBuilderEditor, args?: any): void;
+}
+export declare const createSection: (pageBuilder: PageBuilderEditor) => IPart | undefined;
+export declare const createBlock: (pageBuilder: PageBuilderEditor) => IPart | undefined;
+export declare const findLeafPart: (part: IPart | undefined) => IPart | undefined;
+export declare class AddPartCommand implements Command {
+    private modal;
+    static readonly COMMAND_ID = "AddPart";
+    readonly commandId = "AddPart";
+    readonly caption = "Add Part";
+    constructor(modal: BSModal);
+    execute(pageBuilder: PageBuilderEditor, args?: any): void;
+}
+export declare class AddSectionAboveCommand implements Command {
+    private modal;
+    static readonly COMMAND_ID = "AddSectionAbove";
+    static readonly CAPTION = "Add Part Above";
+    readonly commandId = "AddSectionAbove";
+    readonly caption = "Add Part Above";
+    constructor(modal: BSModal);
+    execute(pageBuilder: PageBuilderEditor, args?: any): void;
+}
+export declare class AddSectionBelowCommand implements Command {
+    private modal;
+    static readonly COMMAND_ID = "AddSectionBelow";
+    static readonly CAPTION = "Add Part Below";
+    readonly commandId = "AddSectionBelow";
+    readonly caption = "Add Part Below";
+    constructor(modal: BSModal);
+    execute(pageBuilder: PageBuilderEditor, args?: any): void;
+}
+export declare class AddBlockLeftCommand implements Command {
+    static readonly COMMAND_ID = "AddBlockLeft";
+    static readonly CAPTION = "Add Block Left";
+    readonly commandId = "AddBlockLeft";
+    readonly caption = "Add Block Left";
+    constructor();
+    execute(pageBuilder: PageBuilderEditor, args?: any): void;
+}
+export declare class AddBlockRightCommand implements Command {
+    static readonly COMMAND_ID = "AddBlockRight";
+    static readonly CAPTION = "Add Block Right";
+    readonly commandId = "AddBlockRight";
+    readonly caption = "Add Block Right";
+    constructor();
+    execute(pageBuilder: PageBuilderEditor, args?: any): void;
+}
+export declare class AddBlockAboveCommand implements Command {
+    static readonly COMMAND_ID = "AddBlockAbove";
+    static readonly CAPTION = "Add Block Above";
+    readonly commandId = "AddBlockAbove";
+    readonly caption = "Add Block Above";
+    constructor();
+    execute(pageBuilder: PageBuilderEditor, args?: any): void;
+}
+export declare class AddBlockBelowCommand implements Command {
+    static readonly COMMAND_ID = "AddBlockBelow";
+    static readonly CAPTION = "Add Block Below";
+    readonly commandId = "AddBlockBelow";
+    readonly caption = "Add Block Below";
+    constructor();
+    execute(pageBuilder: PageBuilderEditor, args?: any): void;
+}
+export declare class AddWidgetLeftCommand implements Command {
+    private modal;
+    static readonly COMMAND_ID = "AddWidgetLeft";
+    static readonly CAPTION = "Add Widget Left";
+    readonly commandId = "AddWidgetLeft";
+    readonly caption = "Add Widget Left";
+    constructor(modal: BSModal);
+    execute(pageBuilder: PageBuilderEditor, args?: any): void;
+}
+export declare class AddWidgetRightCommand implements Command {
+    private modal;
+    static readonly COMMAND_ID = "AddWidgetRight";
+    static readonly CAPTION = "Add Widget Right";
+    readonly commandId = "AddWidgetRight";
+    readonly caption = "Add Widget Right";
+    constructor(modal: BSModal);
+    execute(pageBuilder: PageBuilderEditor, args?: any): void;
+}
+export declare class AddWidgetAboveCommand implements Command {
+    private modal;
+    static readonly COMMAND_ID = "AddWidgetAbove";
+    static readonly CAPTION = "Add Widget Above";
+    readonly commandId = "AddWidgetAbove";
+    readonly caption = "Add Widget Above";
+    constructor(modal: BSModal);
+    execute(pageBuilder: PageBuilderEditor, args?: any): void;
+}
+export declare class AddWidgetBelowCommand implements Command {
+    private modal;
+    static readonly COMMAND_ID = "AddWidgetBelow";
+    static readonly CAPTION = "Add Widget Below";
+    readonly commandId = "AddWidgetBelow";
+    readonly caption = "Add Widget Below";
+    constructor(modal: BSModal);
+    execute(pageBuilder: PageBuilderEditor, args?: any): void;
+}
+export declare class AddWidgetInsideCommand implements Command {
+    private modal;
+    static readonly COMMAND_ID = "AddWidgetInside";
+    static readonly CAPTION = "Add Widget Inside";
+    readonly commandId = "AddWidgetInside";
+    readonly caption = "Add Widget Inside";
+    constructor(modal: BSModal);
+    execute(pageBuilder: PageBuilderEditor, args?: any): void;
+}
+export declare class ChangePropertyCommand implements Command {
+    static readonly COMMAND_ID = "ChangeProperty";
+    readonly commandId = "ChangeProperty";
+    readonly caption = "Change Property";
+    execute(pageBuilder: PageBuilderEditor, args?: any): void;
+}
+export declare class DeletePartCommand implements Command {
+    static readonly COMMAND_ID = "DeletePart";
+    static readonly CAPTION = "Delete";
+    readonly commandId = "DeletePart";
+    readonly caption = "Delete";
+    execute(pageBuilder: PageBuilderEditor): void;
+}
+export declare class CopyPartCommand implements Command {
+    static readonly COMMAND_ID = "CopyPart";
+    readonly commandId = "CopyPart";
+    execute(pageBuilder: PageBuilderEditor): Promise<void>;
+}
+export declare class CutPartCommand implements Command {
+    static readonly COMMAND_ID = "CutPart";
+    readonly commandId = "CutPart";
+    execute(pageBuilder: PageBuilderEditor): void;
+}
+export declare class PastePartCommand implements Command {
+    static readonly COMMAND_ID = "PastePart";
+    readonly commandId = "PastePart";
+    execute(pageBuilder: PageBuilderEditor): Promise<void>;
+}
+export declare class SelectAllPartsCommand implements Command {
+    static readonly COMMAND_ID = "SelectAllParts";
+    readonly commandId = "SelectAllParts";
+    execute(pageBuilder: PageBuilderEditor): void;
+}
+export declare const createDefaultCommands: (modal: BSModal) => (OpenAddPartModalCommand | OpenAddWidgetModalCommand | AddPartCommand | AddSectionAboveCommand | AddSectionBelowCommand | AddBlockLeftCommand | AddBlockRightCommand | AddBlockAboveCommand | AddBlockBelowCommand | AddWidgetLeftCommand | AddWidgetRightCommand | AddWidgetAboveCommand | AddWidgetBelowCommand | AddWidgetInsideCommand | ChangePropertyCommand | DeletePartCommand | CopyPartCommand | CutPartCommand | PastePartCommand | SelectAllPartsCommand)[];
+export declare const menuItemForCommand: (pageBuilder: PageBuilderEditor, commandId: string, caption?: string) => MenuItem;
+export declare const createDefaultContextMenus: () => ContextMenu[];
+export declare const createDefaultKeyHandlers: () => KeyHandler[];
+export declare const createDefaultToolButtonGroups: () => ToolButtonGroup[];

package/dist/model/context.d.ts

@@ -0,0 +1,136 @@
+import { PageBuilderEditor } from './page-builder-editor.ts';
+import { MenuItem } from '@g1cloud/bluesea';
+import { IPart } from '@g1cloud/page-builder-viewer';
+
+export interface PageBuilderContext {
+    setSelection(parts: IPart[]): void;
+    addSelection(parts: IPart[]): void;
+    removeSelection(parts: IPart[] | string[]): void;
+    isSelected(part: IPart): boolean;
+    getSelectedParts(): IPart[];
+    getSelectionCount(): number;
+    hasSelection(): boolean;
+    getSelectedPage(): IPart | undefined;
+    isPageSelected(): boolean;
+    clearSelection(): void;
+    getSingleSelectedWidget(): IPart | undefined;
+    getSingleSelectedBlock(): IPart | undefined;
+    getSingleSelectedSection(): IPart | undefined;
+}
+export declare class PageBuilderContextImpl implements PageBuilderContext {
+    private selection;
+    private model;
+    constructor(pageBuilder: PageBuilderEditor);
+    setSelection(parts: IPart[]): void;
+    addSelection(parts: IPart[]): void;
+    removeSelection(parts: IPart[] | string[]): void;
+    isSelected(part: IPart): boolean;
+    getSelectedParts(): IPart[];
+    getSelectionCount(): number;
+    hasSelection(): boolean;
+    getSelectedPage(): IPart | undefined;
+    isPageSelected(): boolean;
+    clearSelection(): void;
+    getSingleSelectedWidget(): {
+        partType: string;
+        partName: string;
+        partId: string;
+        properties?: Record<string, string> | undefined;
+        children?: any[] | undefined;
+        parent?: any | undefined;
+        isRoot: () => boolean;
+        isPage: () => boolean;
+        isSection: () => boolean;
+        isBlock: () => boolean;
+        isWidget: () => boolean;
+        isNestedWidget: () => boolean;
+        getName: () => string | undefined;
+        getProperty: (propertyName: string) => string | undefined;
+        getClassNames: () => string;
+        getStyles: () => Record<string, string>;
+        getPageBuilderId: () => string | undefined;
+    } | undefined;
+    getSingleSelectedBlock(): {
+        partType: string;
+        partName: string;
+        partId: string;
+        properties?: Record<string, string> | undefined;
+        children?: any[] | undefined;
+        parent?: any | undefined;
+        isRoot: () => boolean;
+        isPage: () => boolean;
+        isSection: () => boolean;
+        isBlock: () => boolean;
+        isWidget: () => boolean;
+        isNestedWidget: () => boolean;
+        getName: () => string | undefined;
+        getProperty: (propertyName: string) => string | undefined;
+        getClassNames: () => string;
+        getStyles: () => Record<string, string>;
+        getPageBuilderId: () => string | undefined;
+    } | undefined;
+    getSingleSelectedSection(): {
+        partType: string;
+        partName: string;
+        partId: string;
+        properties?: Record<string, string> | undefined;
+        children?: any[] | undefined;
+        parent?: any | undefined;
+        isRoot: () => boolean;
+        isPage: () => boolean;
+        isSection: () => boolean;
+        isBlock: () => boolean;
+        isWidget: () => boolean;
+        isNestedWidget: () => boolean;
+        getName: () => string | undefined;
+        getProperty: (propertyName: string) => string | undefined;
+        getClassNames: () => string;
+        getStyles: () => Record<string, string>;
+        getPageBuilderId: () => string | undefined;
+    } | undefined;
+}
+export type ContextMenu = {
+    commandId: string;
+    groupId?: string;
+    precedence?: number;
+    getMenuItem?: (pageBuilder: PageBuilderEditor) => MenuItem | undefined;
+};
+export type ContextMenuGroup = {
+    groupId: string;
+    menus: ContextMenu[];
+};
+export interface ContextMenuRegistry {
+    registerContextMenus(menus: ContextMenu[]): void;
+    registerContextMenu(menu: ContextMenu): void;
+    composeContextMenuItems(pageBuilder: PageBuilderEditor): MenuItem[];
+}
+export type KeyHandler = {
+    handleKeyEvent: (event: KeyboardEvent, modeler: PageBuilderEditor) => boolean | undefined;
+};
+export interface KeyHandlers {
+    appendKeyHandlers(handlers: KeyHandler[]): void;
+    appendKeyHandler(handler: KeyHandler): void;
+    removeKeyHandler(handler: KeyHandler): void;
+    handleKeyDownEvent(event: KeyboardEvent): void;
+    addDocumentKeyEventListener(document: Document): void;
+    removeDocumentKeyEventListener(document: Document): void;
+}
+export declare class ContextMenuRegistryImpl implements ContextMenuRegistry {
+    readonly groups: ContextMenuGroup[];
+    constructor();
+    registerContextMenus(menus: ContextMenu[]): void;
+    registerContextMenu(menu: ContextMenu): void;
+    composeContextMenuItems(pageBuilder: PageBuilderEditor): MenuItem[];
+    private ensureGetGroup;
+}
+export declare class KeyHandlersImpl implements KeyHandlers {
+    private pageBuilder;
+    private handlers;
+    constructor(pageBuilder: PageBuilderEditor);
+    appendKeyHandlers(handlers: KeyHandler[]): void;
+    appendKeyHandler(handler: KeyHandler): void;
+    removeKeyHandler(handler: KeyHandler): void;
+    handleKeyDownEvent(event: KeyboardEvent): void;
+    addDocumentKeyEventListener(document: Document): void;
+    removeDocumentKeyEventListener(document: Document): void;
+}

package/dist/model/default-part-property-editor.d.ts

@@ -0,0 +1,3 @@
+import { PartPropertyEditor, PartPropertyType } from './part-property.ts';
+
+export declare const defaultPartPropertyEditors: () => Record<PartPropertyType, PartPropertyEditor>;

package/dist/model/default-part-property-group.d.ts

@@ -0,0 +1,12 @@
+import { PartPropertyGroup } from './part-property.ts';
+
+export declare const positionGroup: () => PartPropertyGroup;
+export declare const sizeGroup: () => PartPropertyGroup;
+export declare const marginGroup: () => PartPropertyGroup;
+export declare const paddingGroup: () => PartPropertyGroup;
+export declare const commonGroup: () => PartPropertyGroup;
+export declare const layoutGroup: () => PartPropertyGroup;
+export declare const backgroundGroup: () => PartPropertyGroup;
+export declare const borderGroup: () => PartPropertyGroup;
+export declare const defaultPropertyGroups: () => PartPropertyGroup[];
+export declare const defaultWidgetPropertyGroups: () => PartPropertyGroup[];

package/dist/model/event.d.ts

@@ -0,0 +1,71 @@
+import { ModelUpdateResult } from './model';
+
+export type PageBuilderEditorEventType = {
+    modelUpdatedByUI: ModelUpdateResult;
+    modelUpdated: ModelUpdateResult;
+    requestImage: {
+        pageBuilderId?: string;
+        callback: (url: string) => void;
+    };
+    requestProducts: {
+        pageBuilderId?: string;
+        itemCodes: string;
+        callback: (products: any[]) => void;
+    };
+    requestLocalPartContentSchedule: {
+        pageBuilderId?: string;
+        callback: (schedule: any) => void;
+    };
+};
+export declare const PageBuilderEditorEvent: {
+    on: {
+        modelUpdated: (listener: (changes: ModelUpdateResult) => void) => void;
+        modelUpdatedByUI: (listener: (changes: ModelUpdateResult) => void) => void;
+        requestImage: (listener: (param: {
+            pageBuilderId?: string;
+            callback: (url: string) => void;
+        }) => void) => void;
+        requestProducts: (listener: (param: {
+            pageBuilderId?: string;
+            itemCodes: string;
+            callback: (products: any[]) => void;
+        }) => void) => void;
+        requestLocalPartContentSchedule: (listener: (param: {
+            pageBuilderId?: string;
+            callback: (schedule: any) => void;
+        }) => void) => void;
+    };
+    off: {
+        modelUpdated: (listener: (changes: ModelUpdateResult) => void) => void;
+        modelUpdatedByUI: (listener: (changes: ModelUpdateResult) => void) => void;
+        requestImage: (listener: (param: {
+            pageBuilderId?: string;
+            callback: (url: string) => void;
+        }) => void) => void;
+        requestProducts: (listener: (param: {
+            pageBuilderId?: string;
+            itemCodes: string;
+            callback: (products: any[]) => void;
+        }) => void) => void;
+        requestLocalPartContentSchedule: (listener: (param: {
+            callback: (schedule: any) => void;
+        }) => void) => void;
+    };
+    emit: {
+        modelUpdated: (changes: ModelUpdateResult) => void;
+        modelUpdatedByUI: (changes: ModelUpdateResult) => void;
+        requestImage: (param: {
+            pageBuilderId?: string;
+            callback: (url: string) => void;
+        }) => void;
+        requestProducts: (param: {
+            pageBuilderId?: string;
+            itemCodes: string;
+            callback: (products: any[]) => void;
+        }) => void;
+        requestLocalPartContentSchedule: (param: {
+            pageBuilderId?: string;
+            callback: (schedule: any) => void;
+        }) => void;
+    };
+};

package/dist/model/model.d.ts

@@ -0,0 +1,66 @@
+import { IPart } from '@g1cloud/page-builder-viewer';
+import * as Y from 'yjs';
+export declare const ROOT_TYPE = "Root";
+export declare const PAGE_TYPE = "Page";
+export declare const SECTION_TYPE = "Section";
+export declare const BLOCK_TYPE = "Block";
+export declare const WIDGET_TYPE = "Widget";
+export declare const getNewPartId: () => string;
+export declare const partsToJsonString: (parts: IPart[]) => string;
+export declare const partFromJsonObject: (object: any) => IPart | undefined;
+export declare const createPart: (partType: string, partName: string, properties?: Record<string, string>) => IPart | undefined;
+export declare class Model {
+    yjsDoc: Y.Doc;
+    yjsRoot: Y.XmlElement;
+    undoManager: Y.UndoManager;
+    rootPart: IPart;
+    constructor();
+    getRootPartId(): string;
+    updateModel(param: ModelUpdateParam): ModelUpdateResult;
+    findPartById(partId?: string): IPart | undefined;
+    findPartsByIds(partIds: string[]): IPart[];
+    serializePageModel: (partIds: string[]) => string;
+    parsePageModel(json: string, removePartId: boolean): IPart[] | undefined;
+    moveElements(partId: string, destPartId: string, destIndex: number, update?: PartUpdateParam[]): void;
+    isMobilePart(part: IPart): boolean;
+    isPcPart(part: IPart): boolean;
+    private insertParts;
+    private updateParts;
+    private deleteParts;
+    private createElement;
+    private getIndexOfElement;
+    private emitUpdateModelEvent;
+}
+export type PartInsertParam = {
+    partId: string;
+    index: number;
+    parts: IPart[];
+};
+export type PartUpdateParam = {
+    partId: string;
+    properties: Record<string, string>;
+    removeOtherAttributes?: boolean;
+};
+export type PartInsertResult = {
+    element: Y.XmlElement;
+    partId: string;
+};
+export type PartUpdateResult = {
+    element: Y.XmlElement;
+    properties: Record<string, string>;
+    removeOtherProperties?: boolean;
+};
+export type PartDeleteResult = {
+    element: Y.XmlElement;
+    partId: string;
+};
+export type ModelUpdateParam = {
+    insert?: PartInsertParam[];
+    update?: PartUpdateParam[];
+    delete?: string[];
+};
+export type ModelUpdateResult = {
+    inserted?: PartInsertResult[];
+    updated?: PartUpdateResult[];
+    deleted?: PartDeleteResult[];
+};

package/dist/model/page-builder-editor.d.ts

@@ -0,0 +1,51 @@
+import { ContextMenuRegistry, ContextMenuRegistryImpl, KeyHandlers, PageBuilderContext, PageBuilderContextImpl } from './context.ts';
+import { ToolButtonRegistry } from './toolbar.ts';
+import { PageBuilderPlugin } from './plugin.ts';
+import { CommandRegistry, CommandRegistryImpl } from './command';
+import { PartManager } from './part-manager';
+import { Model } from './model';
+import { Ref } from 'vue';
+
+export type PageBuilderEditMode = 'template' | 'global' | 'local' | 'free';
+export declare const createPageBuilderEditor: () => PageBuilderEditor;
+export declare const providePageBuilderEditor: (pageBuilderEditor: PageBuilderEditor) => void;
+export declare const usePageBuilderEditor: () => PageBuilderEditor;
+export interface PageBuilderEditor {
+    instanceId?: string;
+    partManager: PartManager;
+    model: Model;
+    context: PageBuilderContext;
+    commandRegistry: CommandRegistry;
+    contextMenuRegistry: ContextMenuRegistry;
+    keyHandlers: KeyHandlers;
+    toolButtonRegistry: ToolButtonRegistry;
+    title?: string;
+    editMode: PageBuilderEditMode;
+    scale: Ref<number>;
+    registerPlugin(plugin: PageBuilderPlugin): void;
+    initData(content?: any): void;
+    undo(): void;
+    redo(): void;
+    zoom(scale: number): void;
+}
+export declare class PageBuilderEditorImpl implements PageBuilderEditor {
+    instanceId?: string;
+    partManager: PartManager;
+    model: Model;
+    context: PageBuilderContextImpl;
+    commandRegistry: CommandRegistryImpl;
+    contextMenuRegistry: ContextMenuRegistryImpl;
+    keyHandlers: KeyHandlers;
+    toolButtonRegistry: ToolButtonRegistry;
+    title?: string;
+    editMode: PageBuilderEditMode;
+    scale: Ref<number>;
+    constructor();
+    registerPlugin(plugin: PageBuilderPlugin): void;
+    initData(content?: any): void;
+    undo(): void;
+    redo(): void;
+    zoom(scale: number): void;
+    private getEmptyPageContent;
+    private initPlugins;
+}

package/dist/model/page-builder-util.d.ts

@@ -0,0 +1,5 @@
+import { IPart } from '@g1cloud/page-builder-viewer';
+
+export declare const getPropertyValueOfParts: (parts: IPart[], propertyName: string) => string | undefined;
+export declare const isCursorInElement: (event: MouseEvent, element: Element) => boolean;
+export declare const extractCommonStylesFromProperties: (properties: Record<string, string>) => Record<string, unknown>;

package/dist/model/part-definintion.d.ts

@@ -0,0 +1,26 @@
+import { PartPropertyGroup } from './part-property.ts';
+import { Component } from 'vue';
+import { IPart } from '@g1cloud/page-builder-viewer';
+
+export type PartCreator = (part: IPart, partDef: PartDefinition) => Component | undefined;
+export type PartDefinition = {
+    partType: string;
+    partName: string;
+    caption: string;
+    propertyGroups: PartPropertyGroup[];
+    initialProperties: Record<string, string>;
+    localized: boolean;
+    allowsChild: (partOrName?: IPart | string | undefined) => boolean;
+    creator: PartCreator;
+};
+export type PartDefinitionGroup = {
+    groupName: string;
+    caption: string;
+    partDefinitions: PartDefinition[];
+};
+declare const partDefinitions: Record<string, PartDefinition>;
+export { partDefinitions };
+export declare const designPartDefinitions: PartDefinitionGroup[];
+export declare const layoutPartDefinitions: PartDefinitionGroup[];
+export declare const widgetPartDefinitions: PartDefinitionGroup[];
+export declare const blockWidgetPartDefinitions: PartDefinitionGroup[];

package/dist/model/part-manager.d.ts

@@ -0,0 +1,29 @@
+import { PartDefinition } from './part-definintion.ts';
+import { PartProperty, PartPropertyEditor, PartPropertyGroupEditor, PartPropertyType } from './part-property.ts';
+import { IPart } from '@g1cloud/page-builder-viewer';
+import { Component } from 'vue';
+
+export type PartComponent = {
+    part: IPart;
+    component: Component;
+};
+export declare class PartManager {
+    readonly partDefinitions: Record<string, PartDefinition>;
+    readonly partPropertyGroupEditors: Map<string, PartPropertyGroupEditor>;
+    readonly partPropertyEditors: Map<string, PartPropertyEditor>;
+    private readonly partDefinitionMap;
+    registerPartDefinitions(partDefinitions: Record<string, PartDefinition>): void;
+    getPartDefinition(partName: string): PartDefinition | undefined;
+    getPropertyDefinition(partName: string, propertyName: string): PartProperty | undefined;
+    createPartComponent(part?: IPart): Component | undefined;
+    createPartComponents(parts?: IPart[]): PartComponent[];
+    registerPartPropertyGroupEditors(editors: Record<string, PartPropertyGroupEditor>): void;
+    getPartPropertyGroupEditor(groupName: string): PartPropertyGroupEditor | undefined;
+    registerPartPropertyEditors(editors: Record<PartPropertyType, PartPropertyEditor>): void;
+    getPartPropertyEditor(attrType: PartPropertyType): PartPropertyEditor | undefined;
+    findNearestAvailableParentPart(target: IPart, partOrName: IPart | string | undefined): IPart | undefined;
+    getSectionDefinition(): PartDefinition | undefined;
+    getBlockDefinition(): PartDefinition | undefined;
+    findNearestSection(part: IPart): IPart | undefined;
+    findNearestBlock(part: IPart): IPart | undefined;
+}

package/dist/model/part-property.d.ts

@@ -0,0 +1,22 @@
+import { IPart } from '@g1cloud/page-builder-viewer';
+import { Component } from 'vue';
+
+export type PartPropertyType = 'readonly-text' | 'text' | 'number' | 'multiline-text' | 'select' | string;
+export type PartPropertyEditor = (property: PartProperty, parts: IPart[]) => Component | undefined;
+export type PartProperty = {
+    propertyName: string;
+    propertyType: PartPropertyType;
+    caption: string;
+    params?: any;
+    propertyEditor?: PartPropertyEditor;
+    localized?: boolean;
+};
+export type PartPropertyGroupEditor = (group: PartPropertyGroup, parts: IPart[]) => Component | undefined;
+export type PartPropertyGroup = {
+    groupName: string;
+    properties: PartProperty[];
+    caption: string;
+    showGroupName?: boolean;
+    propertyGroupEditor?: PartPropertyGroupEditor;
+    localized?: boolean;
+};

package/dist/model/plugin.d.ts

@@ -0,0 +1,15 @@
+import { PartPropertyEditor, PartPropertyGroupEditor, PartPropertyType } from './part-property.ts';
+import { PartDefinition } from './part-definintion.ts';
+import { ToolButtonGroup } from './toolbar.ts';
+import { ContextMenu, KeyHandler } from './context.ts';
+import { Command } from './command.ts';
+
+export type PageBuilderPlugin = {
+    partDefinitions?: Record<string, PartDefinition>;
+    partPropertyGroupEditors?: Record<string, PartPropertyGroupEditor>;
+    partPropertyEditors?: Record<PartPropertyType, PartPropertyEditor>;
+    commands?: Command[];
+    contextMenus?: ContextMenu[];
+    keyHandlers?: KeyHandler[];
+    toolButtonGroups?: ToolButtonGroup[];
+};

package/dist/model/toolbar.d.ts

@@ -0,0 +1,27 @@
+import { PageBuilderEditor } from './page-builder-editor.ts';
+import { Component } from 'vue';
+
+export type ToolButton = {
+    buttonId: string;
+    caption?: string;
+    component?: () => Component;
+    icon?: string;
+    iconFontSize?: string;
+    handler?: (pageBuilder: PageBuilderEditor) => void;
+};
+export type ToolButtonGroup = {
+    groupId: string;
+    buttons: ToolButton[];
+};
+export interface ToolButtonRegistry {
+    registerToolButtonGroups(groups: ToolButtonGroup[]): void;
+    registerToolButtons(groupId: string, buttons: ToolButton[]): void;
+    getToolButtonGroups(): ToolButtonGroup[];
+}
+export declare class ToolButtonRegistryImpl implements ToolButtonRegistry {
+    private readonly groups;
+    registerToolButtonGroups(groups: ToolButtonGroup[]): void;
+    registerToolButtonGroup(group: ToolButtonGroup): void;
+    registerToolButtons(groupId: string, buttons: ToolButton[]): void;
+    getToolButtonGroups(): ToolButtonGroup[];
+}