@blocklet/pages-kit-core 0.5.29 → 0.5.31

package/lib/cjs/index.d.ts

@@ -1,3 +1 @@
-export * from './types';
-export * from './core';
-export * from './dataset';
+export * from './template-model';

package/lib/cjs/index.js

@@ -14,6 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./types"), exports);
-__exportStar(require("./core"), exports);
-__exportStar(require("./dataset"), exports);
+// export * from './types';
+// export * from './core';
+// export * from './dataset';
+__exportStar(require("./template-model"), exports);

package/lib/cjs/page.js

@@ -45,7 +45,6 @@ class Page {
                 backgroundColor: this.data.meta.backgroundColor,
                 ...input,
             };
-            // @FIXME: 这个 map 应该是不需要的
             // 使用 Block 实例渲染 sections
             const sections = await Promise.all(this.data.sections.map(async (section) => {
                 try {

package/lib/cjs/template-model.d.ts

@@ -0,0 +1,124 @@
+export declare const DEFAULT_CHILDREN_PROPERTIES: string[];
+export declare const PAGES_KIT_CHILDREN_PROPERTIES: ((node: Node) => any)[];
+type WalkStrategy = 'pre' | 'post' | 'breadth';
+export type ChildrenResolver = string | ((node: Node, locale?: string) => any[]);
+interface TemplateModelConfig {
+    childrenProperties?: ChildrenResolver[];
+    locale?: string;
+}
+interface NodeModel {
+    [key: string]: any;
+}
+interface WalkOptions {
+    strategy?: WalkStrategy;
+}
+interface WalkFunction<T = any> {
+    (node: Node): boolean | void | T;
+}
+/**
+ * 表示树中的一个节点
+ */
+export declare class Node {
+    parent?: Node;
+    children: Node[];
+    config: TemplateModelConfig;
+    model: NodeModel;
+    constructor(config: TemplateModelConfig, model: NodeModel);
+    isRoot(): boolean;
+    hasChildren(): boolean;
+    getPath(): Node[];
+    walk(options: WalkOptions, fn?: WalkFunction, ctx?: any): void;
+    walk(fn: WalkFunction, ctx?: any): void;
+    all(options: WalkOptions, fn?: WalkFunction, ctx?: any): Node[];
+    all(fn?: WalkFunction, ctx?: any): Node[];
+    first(options: WalkOptions, fn?: WalkFunction, ctx?: any): Node | undefined;
+    first(fn?: WalkFunction, ctx?: any): Node | undefined;
+    /**
+     * 在所有子节点源中查找节点
+     */
+    findAll(predicate: WalkFunction): Node[];
+    private parseArgs;
+    /**
+     * 获取节点在父节点中的索引
+     */
+    getIndex(): number;
+    /**
+     * 获取节点完整的JSON路径表示
+     * 返回一个能直接访问JSON对象的路径数组
+     */
+    getJsonPath(): string[];
+    /**
+     * 获取节点导出数据
+     */
+    getExportData(): NodeModel;
+    /**
+     * 获取深拷贝
+     */
+    private _cloneObject;
+}
+/**
+ * 树模型类，用于将普通对象转换为树结构
+ */
+export declare class TemplateModel {
+    private config;
+    private componentsById;
+    private rootComponentIds;
+    originalModel: NodeModel | null;
+    parseModel: NodeModel | null;
+    root: Node | null;
+    constructor(config?: TemplateModelConfig);
+    /**
+     * 添加子节点解析器
+     */
+    addChildrenResolver(resolver: ChildrenResolver): void;
+    /**
+     * 新增: 构建扁平索引
+     */
+    private _buildFlatIndex;
+    parse(model: NodeModel, { isClone, }?: {
+        isClone?: boolean;
+    }): Node;
+    /**
+     * 新增: 根据ID快速获取组件节点
+     */
+    getComponentById(id: string): Node | null;
+    /**
+     * 新增: 获取组件所有父节点
+     */
+    getComponentAncestors(id: string): Node[];
+    /**
+     * 新增: 获取组件的子组件
+     */
+    getChildComponents(id: string): Node[];
+    /**
+     * 新增: 获取组件的兄弟组件
+     */
+    getSiblingComponents(id: string): Node[];
+    findAll(tree: Node, predicate: WalkFunction): Node[];
+    /**
+     * 新增: 获取所有根组件
+     */
+    getRootComponents(): Node[];
+    /**
+     * 新增: 检查组件是否存在
+     */
+    hasComponent(id: string): boolean;
+    /**
+     * 获取组件的完整JSON路径表示
+     * 返回一个能直接访问JSON对象的路径数组
+     */
+    getComponentJsonPath(id: string): string[];
+    /**
+     * 获取根节点
+     */
+    getRoot(): Node | null;
+    /**
+     * 获取根节点导出数据
+     */
+    getRootExportData(): NodeModel | null;
+    /**
+     * 获取深拷贝
+     */
+    private _cloneObject;
+}
+export default TemplateModel;

package/lib/cjs/template-model.js

@@ -0,0 +1,475 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateModel = exports.Node = exports.PAGES_KIT_CHILDREN_PROPERTIES = exports.DEFAULT_CHILDREN_PROPERTIES = void 0;
+const cloneDeep_1 = __importDefault(require("lodash/cloneDeep"));
+exports.DEFAULT_CHILDREN_PROPERTIES = ['children'];
+exports.PAGES_KIT_CHILDREN_PROPERTIES = [
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    (node) => {
+        if (Object.keys(node.model.sections || {}).length) {
+            return node.model.sectionIds?.map((id) => node.model.sections?.[id]);
+        }
+        return [];
+    },
+];
+/**
+ * 辅助函数：根据属性路径获取值
+ */
+function getValueByPath(obj, path) {
+    if (!path || !obj)
+        return undefined;
+    return path.split('.').reduce((o, key) => {
+        return o && typeof o === 'object' && key in o ? o[key] : undefined;
+    }, obj);
+}
+/**
+ * 表示树中的一个节点
+ */
+class Node {
+    parent;
+    children = [];
+    config;
+    model;
+    constructor(config, model) {
+        this.config = config;
+        this.model = model;
+    }
+    isRoot() {
+        return this.parent === undefined;
+    }
+    hasChildren() {
+        return this.children.length > 0;
+    }
+    getPath() {
+        const path = [];
+        const addToPath = (node) => {
+            path.unshift(node);
+            if (!node.isRoot() && node.parent) {
+                addToPath(node.parent);
+            }
+        };
+        addToPath(this);
+        return path;
+    }
+    walk(...args) {
+        const parsedArgs = this.parseArgs(...args);
+        const strategy = parsedArgs.options.strategy;
+        walkStrategies[strategy].call(this, parsedArgs.fn, parsedArgs.ctx);
+    }
+    all(...args) {
+        const all = [];
+        const parsedArgs = this.parseArgs(...args);
+        parsedArgs.fn = parsedArgs.fn || createConstantFunction(true);
+        walkStrategies[parsedArgs.options.strategy].call(this, (node) => {
+            if (parsedArgs.fn.call(parsedArgs.ctx, node)) {
+                all.push(node);
+            }
+            return undefined;
+        }, parsedArgs.ctx);
+        return all;
+    }
+    first(...args) {
+        let first;
+        const parsedArgs = this.parseArgs(...args);
+        parsedArgs.fn = parsedArgs.fn || createConstantFunction(true);
+        walkStrategies[parsedArgs.options.strategy].call(this, (node) => {
+            if (parsedArgs.fn.call(parsedArgs.ctx, node)) {
+                first = node;
+                return false;
+            }
+            return undefined;
+        }, parsedArgs.ctx);
+        return first;
+    }
+    /**
+     * 在所有子节点源中查找节点
+     */
+    findAll(predicate) {
+        // 首先使用标准遍历找到直接子节点中符合条件的
+        const standardResults = this.all(predicate);
+        return standardResults;
+    }
+    parseArgs(...args) {
+        const parsedArgs = {
+            options: {},
+            fn: () => true,
+        };
+        if (args.length === 1) {
+            if (typeof args[0] === 'function') {
+                const [fn] = args;
+                parsedArgs.fn = fn;
+            }
+            else {
+                const [options] = args;
+                parsedArgs.options = options;
+            }
+        }
+        else if (args.length === 2) {
+            if (typeof args[0] === 'function') {
+                const [fn, ctx] = args;
+                parsedArgs.fn = fn;
+                parsedArgs.ctx = ctx;
+            }
+            else {
+                const [options, fn] = args;
+                parsedArgs.options = options;
+                parsedArgs.fn = fn;
+            }
+        }
+        else if (args.length >= 3) {
+            const [options, fn, ctx] = args;
+            parsedArgs.options = options;
+            parsedArgs.fn = fn;
+            parsedArgs.ctx = ctx;
+        }
+        parsedArgs.options = parsedArgs.options || {};
+        if (!parsedArgs.options.strategy) {
+            parsedArgs.options.strategy = 'pre';
+        }
+        const strategy = parsedArgs.options.strategy;
+        if (!walkStrategies[strategy]) {
+            throw new Error("Unknown tree walk strategy. Valid strategies are 'pre' [default], 'post' and 'breadth'.");
+        }
+        return parsedArgs;
+    }
+    /**
+     * 获取节点在父节点中的索引
+     */
+    getIndex() {
+        return this.parent?.children.indexOf(this) || 0;
+    }
+    /**
+     * 获取节点完整的JSON路径表示
+     * 返回一个能直接访问JSON对象的路径数组
+     */
+    getJsonPath() {
+        const jsonPath = [];
+        const buildJsonPath = (node) => {
+            if (!node.parent) {
+                // 根节点
+                return;
+            }
+            const { parent } = node;
+            // 先构建父节点的路径
+            buildJsonPath(parent);
+            // 查找当前节点在父节点中的路径
+            if (Array.isArray(parent.config.childrenProperties) && parent.config.childrenProperties.length > 0) {
+                for (const resolver of parent.config.childrenProperties) {
+                    if (typeof resolver === 'string') {
+                        // 字符串路径
+                        const pathParts = resolver.split('.');
+                        let current = parent.model;
+                        let isValid = true;
+                        // 检查路径是否有效
+                        for (let i = 0; i < pathParts.length; i++) {
+                            const part = pathParts[i];
+                            if (!part || !current || typeof current !== 'object' || !(part in current)) {
+                                isValid = false;
+                                break;
+                            }
+                            current = current[part];
+                        }
+                        if (isValid && Array.isArray(current)) {
+                            // 在数组中查找当前节点
+                            const index = current.findIndex((item) => item === node.model);
+                            if (index !== -1) {
+                                jsonPath.push(...pathParts, index.toString());
+                                return;
+                            }
+                        }
+                    }
+                    else if (typeof resolver === 'function') {
+                        // 对于函数解析器，尝试通过特殊情况处理
+                        // 处理layout-block的情况
+                        if (parent.model.component === 'layout-block' && parent.model.sections) {
+                            const index = parent.model.sections.findIndex((section) => section === node.model);
+                            if (index !== -1) {
+                                jsonPath.push('sections', index.toString());
+                                return;
+                            }
+                        }
+                        // 处理根节点的sections情况
+                        if (parent.isRoot() && parent.model.sections) {
+                            const sections = Object.values(parent.model.sections);
+                            const index = sections.findIndex((section) => section === node.model);
+                            if (index !== -1 && parent.model.sections) {
+                                const keys = Object.keys(parent.model.sections);
+                                if (index < keys.length) {
+                                    const key = keys[index];
+                                    if (key) {
+                                        jsonPath.push('sections', key);
+                                        return;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            // 默认处理方式
+            if (node.model.id && parent.model.sections && node.model.id in parent.model.sections) {
+                jsonPath.push('sections', node.model.id);
+            }
+            else {
+                // 最后尝试查找节点在children数组中的位置
+                const index = parent.children.indexOf(node);
+                if (index !== -1 && Array.isArray(parent.model.children)) {
+                    jsonPath.push('children', index.toString());
+                }
+            }
+        };
+        buildJsonPath(this);
+        return jsonPath;
+    }
+    /**
+     * 获取节点导出数据
+     */
+    getExportData() {
+        return this._cloneObject(this.model);
+    }
+    /**
+     * 获取深拷贝
+     */
+    _cloneObject(obj) {
+        return (0, cloneDeep_1.default)(obj);
+    }
+}
+exports.Node = Node;
+// 定义遍历策略
+const walkStrategies = {
+    pre: function depthFirstPreOrder(callback, context) {
+        let keepGoing = callback.call(context, this);
+        for (let i = 0, childCount = this.children.length; i < childCount; i++) {
+            if (keepGoing === false) {
+                return false;
+            }
+            // 类型安全调用
+            const child = this.children[i];
+            if (child instanceof Node) {
+                keepGoing = depthFirstPreOrder.call(child, callback, context);
+            }
+        }
+        return keepGoing;
+    },
+    post: function depthFirstPostOrder(callback, context) {
+        let keepGoing;
+        for (let i = 0, childCount = this.children.length; i < childCount; i++) {
+            // 类型安全调用
+            const child = this.children[i];
+            if (child instanceof Node) {
+                keepGoing = depthFirstPostOrder.call(child, callback, context);
+                if (keepGoing === false) {
+                    return false;
+                }
+            }
+        }
+        keepGoing = callback.call(context, this);
+        return keepGoing;
+    },
+    breadth: function breadthFirst(callback, context) {
+        const queue = [this];
+        const processQueue = () => {
+            if (queue.length === 0) {
+                return;
+            }
+            const node = queue.shift();
+            if (!node)
+                return;
+            for (let i = 0, childCount = node.children.length; i < childCount; i++) {
+                const child = node.children[i];
+                if (child instanceof Node) {
+                    queue.push(child);
+                }
+            }
+            if (callback.call(context, node) !== false) {
+                processQueue();
+            }
+        };
+        processQueue();
+    },
+};
+function createConstantFunction(result) {
+    return () => result;
+}
+/**
+ * 树模型类，用于将普通对象转换为树结构
+ */
+class TemplateModel {
+    config;
+    componentsById = {};
+    rootComponentIds = [];
+    originalModel = null;
+    parseModel = null;
+    root = null;
+    constructor(config = {}) {
+        this.config = {};
+        // 处理子节点解析配置
+        if (config.childrenProperties) {
+            // 使用多源配置
+            this.config.childrenProperties = config.childrenProperties;
+        }
+        else {
+            // 默认使用children
+            this.config.childrenProperties = exports.DEFAULT_CHILDREN_PROPERTIES;
+        }
+        this.config.locale = config.locale || 'en';
+    }
+    /**
+     * 添加子节点解析器
+     */
+    addChildrenResolver(resolver) {
+        if (!this.config.childrenProperties) {
+            this.config.childrenProperties = [];
+        }
+        this.config.childrenProperties.push(resolver);
+    }
+    /**
+     * 新增: 构建扁平索引
+     */
+    _buildFlatIndex(rootNode) {
+        // 清空现有索引
+        this.componentsById = {};
+        this.rootComponentIds = [];
+        // 如果根节点有ID，将其加入根组件列表
+        if (rootNode.model.id) {
+            this.rootComponentIds.push(rootNode.model.id);
+        }
+        // 遍历所有节点建立索引
+        rootNode.walk((node) => {
+            if (node.model.id) {
+                this.componentsById[node.model.id] = node;
+            }
+            return undefined;
+        });
+    }
+    parse(model, { isClone = false, } = {}) {
+        this.originalModel = model;
+        // 创建深拷贝，避免直接修改原始对象
+        const realModel = isClone ? this._cloneObject(model) : model;
+        if (!(realModel instanceof Object)) {
+            throw new TypeError('Model must be of type object.');
+        }
+        const node = new Node(this.config, realModel);
+        // 获取子节点模型
+        const childrenModels = [];
+        if (Array.isArray(this.config.childrenProperties)) {
+            // 使用解析器获取子节点
+            for (const resolver of this.config.childrenProperties) {
+                if (typeof resolver === 'string') {
+                    // 字符串路径
+                    const value = getValueByPath(realModel, resolver);
+                    if (Array.isArray(value)) {
+                        childrenModels.push(...value);
+                    }
+                }
+                else if (typeof resolver === 'function') {
+                    // 函数解析器 - 创建临时节点以便调用
+                    const tempNode = new Node(this.config, realModel);
+                    const value = resolver(tempNode, this.config.locale);
+                    if (Array.isArray(value)) {
+                        childrenModels.push(...value);
+                    }
+                }
+            }
+        }
+        // 解析所有子节点
+        for (let i = 0; i < childrenModels.length; i++) {
+            const childNode = this.parse(childrenModels[i], {
+                isClone: false,
+            });
+            childNode.parent = node;
+            node.children.push(childNode);
+        }
+        // 新增: 构建扁平索引
+        this._buildFlatIndex(node);
+        this.root = node;
+        this.parseModel = realModel;
+        return node;
+    }
+    /**
+     * 新增: 根据ID快速获取组件节点
+     */
+    getComponentById(id) {
+        return this.componentsById[id] || null;
+    }
+    /**
+     * 新增: 获取组件所有父节点
+     */
+    getComponentAncestors(id) {
+        const node = this.getComponentById(id);
+        if (!node)
+            return [];
+        // 使用现有getPath方法，但排除自身
+        const path = node.getPath();
+        return path.slice(0, -1);
+    }
+    /**
+     * 新增: 获取组件的子组件
+     */
+    getChildComponents(id) {
+        const node = this.getComponentById(id);
+        if (!node)
+            return [];
+        return node.children;
+    }
+    /**
+     * 新增: 获取组件的兄弟组件
+     */
+    getSiblingComponents(id) {
+        const node = this.getComponentById(id);
+        if (!node || !node.parent)
+            return [];
+        return node.parent.children.filter((child) => child !== node);
+    }
+    // 新增：递归查找所有匹配节点（包括嵌套源）
+    findAll(tree, predicate) {
+        return tree.findAll(predicate);
+    }
+    /**
+     * 新增: 获取所有根组件
+     */
+    getRootComponents() {
+        return this.rootComponentIds.map((id) => this.componentsById[id]).filter((item) => item !== undefined);
+    }
+    /**
+     * 新增: 检查组件是否存在
+     */
+    hasComponent(id) {
+        return !!this.componentsById[id];
+    }
+    /**
+     * 获取组件的完整JSON路径表示
+     * 返回一个能直接访问JSON对象的路径数组
+     */
+    getComponentJsonPath(id) {
+        const node = this.getComponentById(id);
+        if (!node)
+            return [];
+        return node.getJsonPath();
+    }
+    /**
+     * 获取根节点
+     */
+    getRoot() {
+        return this.root;
+    }
+    /**
+     * 获取根节点导出数据
+     */
+    getRootExportData() {
+        if (!this.root)
+            return null;
+        return this.root.getExportData();
+    }
+    /**
+     * 获取深拷贝
+     */
+    _cloneObject(obj) {
+        return (0, cloneDeep_1.default)(obj);
+    }
+}
+exports.TemplateModel = TemplateModel;
+exports.default = TemplateModel;