@toototech/webbuilder-plugins 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { componentsBasic } from './basic/index.js';
+export { componentsCms } from './cms/index.js';
+export { globalSettings } from './global-settings/index.js';
+export { layoutTemplate } from './layout-template/index.js';
+export { webBuilderI18n } from './i18n/index.js';
+export type { ComponentsBasicPluginOptions, BasicRegistryFailureDiagnostic, BasicRegistryManifestEntry, } from './basic/index.js';
+export type { CmsComponentsRuntime } from './cms/index.js';
+export type { WebBuilderI18nRuntime } from './i18n/index.js';
+export type { LayoutTemplatePluginRuntime } from './layout-template/index.js';

package/dist/index.js

@@ -0,0 +1,12 @@
+import { c } from "./plugin-DebyCjXx.js";
+import { c as c2 } from "./plugin-C0PrxrIe.js";
+import { c as c3 } from "./plugin-DQshk1sY.js";
+import { c as c4 } from "./plugin-BPA8qlaC.js";
+import { c as c5 } from "./plugin-Dr6TOtyH.js";
+export {
+  c as componentsBasic,
+  c2 as componentsCms,
+  c3 as globalSettings,
+  c4 as layoutTemplate,
+  c5 as webBuilderI18n
+};

package/dist/layout-template/components/LayoutPanel.vue.d.ts

@@ -0,0 +1,37 @@
+import { type WebBuilderLayoutSettings } from '../utils/layoutSettings';
+import { type RulePageOption } from '../utils/layoutRulePages';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    pages: any[];
+    layoutSettings: WebBuilderLayoutSettings;
+    setLayoutSettings: (settings: WebBuilderLayoutSettings) => void;
+    loadRulePageOptions: () => Promise<RulePageOption[]>;
+    ensureRulesEditable?: ((silent?: boolean) => Promise<boolean>) | undefined;
+    getRulesLockState?: (() => {
+        status?: string;
+        message?: string;
+    }) | undefined;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: () => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    pages: any[];
+    layoutSettings: WebBuilderLayoutSettings;
+    setLayoutSettings: (settings: WebBuilderLayoutSettings) => void;
+    loadRulePageOptions: () => Promise<RulePageOption[]>;
+    ensureRulesEditable?: ((silent?: boolean) => Promise<boolean>) | undefined;
+    getRulesLockState?: (() => {
+        status?: string;
+        message?: string;
+    }) | undefined;
+}>>> & Readonly<{
+    onChange?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/layout-template/components/TemplateRulesPanel.vue.d.ts

@@ -0,0 +1,41 @@
+import { type TempTemplateResourceType } from '../config/templateSharedResources';
+import { type TemplateRule } from '../utils/templateRules';
+interface TemplateRuleFieldOption {
+    value: string | number;
+    label: string;
+}
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    currentTemplateType: TempTemplateResourceType | null;
+    currentRules: TemplateRule[];
+    ensureRulesEditable?: ((silent?: boolean) => Promise<boolean>) | undefined;
+    getRulesLockState?: (() => {
+        status?: string;
+        message?: string;
+    }) | undefined;
+    addRule?: (() => Promise<void>) | undefined;
+    patchRule?: ((ruleId: string, patch: Partial<TemplateRule>) => Promise<void>) | undefined;
+    removeRule?: ((ruleId: string) => Promise<void>) | undefined;
+    getFieldOptions?: ((templateType: TempTemplateResourceType | null, fieldKey: string) => TemplateRuleFieldOption[]) | undefined;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    currentTemplateType: TempTemplateResourceType | null;
+    currentRules: TemplateRule[];
+    ensureRulesEditable?: ((silent?: boolean) => Promise<boolean>) | undefined;
+    getRulesLockState?: (() => {
+        status?: string;
+        message?: string;
+    }) | undefined;
+    addRule?: (() => Promise<void>) | undefined;
+    patchRule?: ((ruleId: string, patch: Partial<TemplateRule>) => Promise<void>) | undefined;
+    removeRule?: ((ruleId: string) => Promise<void>) | undefined;
+    getFieldOptions?: ((templateType: TempTemplateResourceType | null, fieldKey: string) => TemplateRuleFieldOption[]) | undefined;
+}>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/layout-template/config/layoutSharedResources.d.ts

@@ -0,0 +1,9 @@
+import { type LayoutSlotKey, type WebBuilderLayoutSettings } from '../utils/layoutSettings';
+export declare const LAYOUT_RULES_RESOURCE_SCOPE = "OWNED";
+export declare const LAYOUT_RULES_RESOURCE_KEY = "layout.rules";
+export declare const LAYOUT_RULES_RESOURCE_TYPE = "LAYOUT_RULES";
+export declare const LAYOUT_PAGE_RESOURCE_SCOPE = "SHARED";
+export declare const LAYOUT_PAGE_RESOURCE_TYPES: Record<LayoutSlotKey, string>;
+export declare const buildLayoutPageResourceKey: (slotKey: LayoutSlotKey, layoutPageId: string) => string;
+export declare const createDefaultLayoutRulesPayload: () => WebBuilderLayoutSettings;
+export declare const normalizeLayoutRulesPayload: (payload?: WebBuilderLayoutSettings | Partial<WebBuilderLayoutSettings> | null) => WebBuilderLayoutSettings;

package/dist/layout-template/config/templateSharedResources.d.ts

@@ -0,0 +1,28 @@
+export declare const TEMP_RULES_RESOURCE_SCOPE = "OWNED";
+export declare const TEMP_RULES_RESOURCE_KEY = "template.rules";
+export declare const TEMP_RULES_RESOURCE_TYPE = "TEMP_RULES";
+export declare const TEMP_TEMPLATE_RESOURCE_TYPES: readonly ["TEMP_POST_DETAIL", "TEMP_POST_CATEGORY_LIST", "TEMP_PRODUCT_DETAIL", "TEMP_PRODUCT_CATEGORY_LIST", "TEMP_MEDIA_DETAIL", "TEMP_MEDIA_CATEGORY_LIST", "TEMP_LOOP_ITEM", "TEMP_POPUP"];
+export type TempTemplateResourceType = (typeof TEMP_TEMPLATE_RESOURCE_TYPES)[number];
+export declare const TEMP_TEMPLATE_RESOURCE_TYPE_OPTIONS: Array<{
+    label: string;
+    value: TempTemplateResourceType;
+}>;
+export declare const isTempTemplateResourceType: (resourceType?: string | null) => resourceType is "TEMP_POST_DETAIL" | "TEMP_POST_CATEGORY_LIST" | "TEMP_PRODUCT_DETAIL" | "TEMP_PRODUCT_CATEGORY_LIST" | "TEMP_MEDIA_DETAIL" | "TEMP_MEDIA_CATEGORY_LIST" | "TEMP_LOOP_ITEM" | "TEMP_POPUP";
+export declare const isTempDetailResourceType: (resourceType?: string | null) => boolean;
+export declare const isTempCategoryListResourceType: (resourceType?: string | null) => boolean;
+export declare const POPUP_TEMPLATE_RESOURCE_TYPE = "TEMP_POPUP";
+export declare const isPopupTemplateResourceType: (resourceType?: string | null) => boolean;
+export type LoopItemType = 'post' | 'postCategory' | 'product' | 'productCategory' | 'productCategoryFaq' | 'media' | 'mediaCategory';
+export interface LoopItemResourceExt {
+    loopItemType?: LoopItemType;
+}
+export declare const LOOP_ITEM_RESOURCE_TYPE = "TEMP_LOOP_ITEM";
+export declare const LOOP_ITEM_TYPE_LABELS: Record<LoopItemType, string>;
+export declare const LOOP_ITEM_TYPE_OPTIONS: Array<{
+    label: string;
+    value: LoopItemType;
+}>;
+export declare function parseLoopItemResourceExt(extJson?: string | null): LoopItemResourceExt;
+export declare function getLoopItemType(extJson?: string | null): LoopItemType | '';
+export declare function getLoopItemTypeLabel(extJson?: string | null): string;
+export declare function buildLoopItemResourceExt(loopItemType: LoopItemType): string;

package/dist/layout-template/index.d.ts

@@ -0,0 +1,9 @@
+export * from './plugin.js';
+export { createLayoutTemplatePlugin as layoutTemplate } from './plugin.js';
+export * from './config/layoutSharedResources.js';
+export * from './config/templateSharedResources.js';
+export * from './runtime/storageAdapter.js';
+export * from './utils/layoutProjectData.js';
+export * from './utils/layoutRulePages.js';
+export * from './utils/layoutSettings.js';
+export * from './utils/templateRules.js';

package/dist/layout-template/plugin.d.ts

@@ -0,0 +1,13 @@
+import type { ResourceTransactionParticipant, WebBuilderFeaturePlugin, WebBuilderPanelContribution, WebBuilderPluginContext } from '@toototech/webbuilder/core';
+export declare const LAYOUT_TEMPLATE_PLUGIN_ID = "layout-template";
+export type LayoutTemplatePanelRuntime = Partial<Pick<WebBuilderPanelContribution, 'label' | 'order' | 'icon' | 'preserveOnSelection' | 'component' | 'props'>>;
+export interface LayoutTemplatePluginRuntime {
+    panels?: {
+        layout?: LayoutTemplatePanelRuntime;
+        template?: LayoutTemplatePanelRuntime;
+    };
+    collectResourceParticipants?: (context: WebBuilderPluginContext) => ResourceTransactionParticipant[];
+    collectLockParticipants?: (context: WebBuilderPluginContext) => ResourceTransactionParticipant[];
+    beforeProjectLoad?: (context: WebBuilderPluginContext) => Promise<void> | void;
+}
+export declare const createLayoutTemplatePlugin: (runtime?: LayoutTemplatePluginRuntime) => WebBuilderFeaturePlugin;

package/dist/layout-template/runtime/storageAdapter.d.ts

@@ -0,0 +1,49 @@
+import type { PageResourceIdentity } from '@toototech/webbuilder/core';
+export interface LayoutTemplatePageRecord extends PageResourceIdentity {
+    id?: number;
+    resourceId?: number;
+    resourceKey?: string;
+    resourceName?: string;
+    resourceType?: string;
+    resourceScope?: string;
+    ownerType?: string;
+    ownerId?: number;
+    schemaJson?: string;
+    extJson?: string;
+    createTime?: Date | string;
+    updateTime?: Date | string;
+}
+export interface LayoutTemplatePageListResult<T = LayoutTemplatePageRecord> {
+    list?: T[];
+    total?: number;
+}
+export interface LayoutTemplateSaveRequest extends PageResourceIdentity {
+    resourceId?: number;
+    resourceKey?: string;
+    resourceName?: string;
+    resourceType?: string;
+    resourceScope?: string;
+    schemaJson?: string;
+    extJson?: string;
+    baseUpdateTime?: Date | string;
+    forceOverride?: boolean;
+    sessionKey?: string;
+}
+export interface LayoutTemplatePublishRequest extends LayoutTemplateSaveRequest {
+}
+export interface LayoutTemplatePageQuery extends PageResourceIdentity {
+    pageNo?: number;
+    pageSize?: number;
+    resourceTypes?: string[];
+    resourceType?: string;
+    resourceScope?: string;
+    status?: string | number;
+}
+export interface LayoutTemplateStorageAdapter {
+    getDraft: (resource: PageResourceIdentity) => Promise<LayoutTemplatePageRecord | null>;
+    saveDraft: (request: LayoutTemplateSaveRequest) => Promise<LayoutTemplatePageRecord>;
+    publishVersion: (request: LayoutTemplatePublishRequest) => Promise<unknown>;
+}
+export interface LayoutTemplateListStorageAdapter extends LayoutTemplateStorageAdapter {
+    getPagePage: (params: LayoutTemplatePageQuery) => Promise<LayoutTemplatePageListResult>;
+}

package/dist/layout-template/utils/layoutProjectData.d.ts

@@ -0,0 +1,15 @@
+import { type LayoutSlotKey, type WebBuilderLayoutSettings } from './layoutSettings';
+type ProjectData = Record<string, any>;
+export interface LegacyLayoutBundle {
+    pageProjectData: ProjectData | null;
+    layoutPages: Record<string, any>[];
+    layoutSettings: WebBuilderLayoutSettings;
+}
+export declare const extractLegacyLayoutBundle: (projectData: ProjectData | null | undefined) => LegacyLayoutBundle;
+export declare const mergeLayoutBundleProjectData: (pageProjectData: ProjectData | null | undefined, layoutProjectDataList: Array<ProjectData | null | undefined>) => ProjectData;
+export declare const buildPageOnlyProjectData: (fullProjectData: ProjectData | null | undefined) => ProjectData;
+export declare const buildLayoutPageProjectData: (fullProjectData: ProjectData | null | undefined, layoutPageId: string) => ProjectData | null;
+export declare const buildSinglePageProjectData: (baseProjectData: ProjectData | null | undefined, pageData: Record<string, any>) => ProjectData;
+export declare const buildLayoutProjectDataMap: (fullProjectData: ProjectData | null | undefined) => Record<string, ProjectData>;
+export declare const groupLayoutPagesBySlot: (pages: Record<string, any>[]) => Record<LayoutSlotKey, Record<string, any>[]>;
+export {};

package/dist/layout-template/utils/layoutRulePages.d.ts

@@ -0,0 +1,19 @@
+export type RulePageOption = {
+    id: string;
+    label: string;
+};
+export interface SelectablePageRow {
+    resourceKey?: string | null;
+    resourceName?: string | null;
+}
+export interface RulePageListParams {
+    pageNo: number;
+    pageSize: number;
+    status?: string;
+    resourceType?: string;
+}
+export interface RulePageListResult {
+    list?: SelectablePageRow[];
+}
+export declare const toRulePageOptions: (rows: SelectablePageRow[] | null | undefined) => RulePageOption[];
+export declare const loadRulePageOptions: (fetchPageList: (params: RulePageListParams) => Promise<RulePageListResult>) => Promise<RulePageOption[]>;

package/dist/layout-template/utils/layoutSettings.d.ts

@@ -0,0 +1,45 @@
+export type LayoutTarget = string | number | null;
+export type LayoutMatchMode = 'include' | 'exclude';
+export type LayoutSlotKey = 'header' | 'footer';
+export declare const WB_LAYOUT_PAGE_CUSTOM_KEY = "wbLayoutSlot";
+export declare const WB_LAYOUT_PAGE_ID_CUSTOM_KEY = "wbLayoutPageId";
+export interface LayoutRule {
+    id: string;
+    name?: string;
+    layoutId: LayoutTarget;
+    matchMode: LayoutMatchMode;
+    pageIds: string[];
+    enabled: boolean;
+    priority: number;
+    sourceUpdatedAt?: string;
+    sourceResourceId?: number;
+}
+export interface LayoutSlot {
+    defaultLayoutId: LayoutTarget;
+    rules: LayoutRule[];
+}
+export interface WebBuilderLayoutSettings {
+    version: 1;
+    header: LayoutSlot;
+    footer: LayoutSlot;
+}
+export declare const createDefaultLayoutSettings: () => WebBuilderLayoutSettings;
+export declare const normalizeLayoutSettings: (settings: unknown) => WebBuilderLayoutSettings;
+export declare const cloneLayoutSettings: (settings: WebBuilderLayoutSettings | Partial<WebBuilderLayoutSettings> | null | undefined) => WebBuilderLayoutSettings;
+export declare const getGrapesPageId: (page: any) => string;
+export declare const getGrapesPageName: (page: any) => string;
+export declare const getGrapesPageRouteId: (page: any) => string;
+export declare const getGrapesPageMatchIds: (page: any) => string[];
+export declare const getPageLayoutSlot: (page: any) => LayoutSlotKey | null;
+export declare const isLayoutPage: (page: any) => boolean;
+export declare const getLayoutPageFallbackName: (layoutId: LayoutTarget) => string;
+export declare const getLayoutTargetAliases: (layoutId: LayoutTarget) => string[];
+export declare const getLayoutPageAliases: (page: any) => string[];
+export declare const layoutTargetMatchesPage: (layoutId: LayoutTarget, page: any) => boolean;
+export declare const createLayoutPageData: (slotKey: LayoutSlotKey, existingPages?: any[], reservedLayoutIds?: LayoutTarget[]) => {
+    id: string;
+    name: string;
+    custom: Record<string, any>;
+    component: any;
+};
+export declare const resolveLayoutIdForPage: (slot: LayoutSlot | null | undefined, pageId: string | string[], availableLayoutIds?: LayoutTarget[]) => LayoutTarget;

package/dist/layout-template/utils/templateRules.d.ts

@@ -0,0 +1,52 @@
+import { type TempTemplateResourceType } from '../config/templateSharedResources';
+export interface TemplateTimeRange {
+    start?: string;
+    end?: string;
+}
+export interface TemplateRuleConditions {
+    postIds?: number[];
+    excludePostIds?: number[];
+    typeIds?: number[];
+    excludeTypeIds?: number[];
+    tagIds?: number[];
+    templateNames?: string[];
+    publishTimeRange?: TemplateTimeRange;
+    resourceIds?: number[];
+    excludeResourceIds?: number[];
+    categoryIds?: number[];
+    excludeCategoryIds?: number[];
+    mediaTypes?: string[];
+    spuIds?: number[];
+    excludeSpuIds?: number[];
+    brandIds?: number[];
+    createTimeRange?: TemplateTimeRange;
+    rootCategoryIds?: number[];
+    levels?: number[];
+}
+export interface TemplateRule {
+    id: string;
+    name?: string;
+    templateType: TempTemplateResourceType;
+    templateResourceId?: number;
+    templateResourceKey?: string;
+    enabled: boolean;
+    priority: number;
+    conditions: TemplateRuleConditions;
+}
+export interface WebBuilderTemplateRules {
+    version: 1;
+    postDetail: TemplateRule[];
+    postCategoryList: TemplateRule[];
+    mediaDetail: TemplateRule[];
+    mediaCategoryList: TemplateRule[];
+    productDetail: TemplateRule[];
+    productCategoryList: TemplateRule[];
+}
+type TemplateRuleBucketKey = keyof Omit<WebBuilderTemplateRules, 'version'>;
+export declare const createDefaultTemplateRulesPayload: () => WebBuilderTemplateRules;
+export declare const normalizeTemplateRulesPayload: (value: unknown) => WebBuilderTemplateRules;
+export declare const cloneTemplateRulesPayload: (value?: WebBuilderTemplateRules | Partial<WebBuilderTemplateRules> | null) => WebBuilderTemplateRules;
+export declare const getTemplateRuleBucketKey: (templateType: TempTemplateResourceType) => TemplateRuleBucketKey | null;
+export declare const getTemplateRulesForType: (payload: WebBuilderTemplateRules, templateType: TempTemplateResourceType) => TemplateRule[];
+export declare const setTemplateRulesForType: (payload: WebBuilderTemplateRules, templateType: TempTemplateResourceType, rules: TemplateRule[]) => WebBuilderTemplateRules;
+export {};

package/dist/layout-template/vue.d.ts

@@ -0,0 +1,2 @@
+export { default as LayoutPanel } from './components/LayoutPanel.vue';
+export { default as TemplateRulesPanel } from './components/TemplateRulesPanel.vue';