semanticdb-core 1.1.1 → 1.1.3

package/dist/index.d.ts

@@ -9,6 +9,7 @@ export { getDrilldownDimensions } from './schema/schema.utils/getDrilldownDimens
 export * from './logicform/logicform';
 export * from './logicform/logicform.utils';
 export * from './logicform/types/query';
-export * from './logicform/nameForPredNode';
+export * from './logicform/preds/nameForPredItem';
+export * from './logicform/preds/propertyForPredItem';
 export * from './custom-function/utils';
 export * from './result/index';

package/dist/index.js

@@ -27,6 +27,7 @@ Object.defineProperty(exports, "getDrilldownDimensions", { enumerable: true, get
 __exportStar(require("./logicform/logicform"), exports);
 __exportStar(require("./logicform/logicform.utils"), exports);
 __exportStar(require("./logicform/types/query"), exports);
-__exportStar(require("./logicform/nameForPredNode"), exports);
+__exportStar(require("./logicform/preds/nameForPredItem"), exports);
+__exportStar(require("./logicform/preds/propertyForPredItem"), exports);
 __exportStar(require("./custom-function/utils"), exports);
 __exportStar(require("./result/index"), exports);

package/dist/logicform/logicform.d.ts

@@ -19,6 +19,7 @@ export interface GroupbyItemType {
     level?: string;
     name?: string;
     schema?: SchemaType;
+    order?: string[];
 }
 export interface LogicformType {
     schema: string;

package/dist/logicform/preds/nameForPredItem.d.ts

@@ -0,0 +1,24 @@
+import { SchemaType } from '../../schema/schema';
+import { PredItemType } from '../logicform';
+import { QueryType } from '../types/query';
+export interface ctx {
+    schemas: Record<string, SchemaType>;
+    customFunctions: Record<string, any>;
+    locale?: string;
+}
+/**
+ * 给Query起名
+ */
+export declare const nameForQuery: (query: QueryType, schema: SchemaType, schemas: Record<string, SchemaType>) => string;
+/**
+ * 给pred item起名, normalize阶段用到
+ * @param predItem - PredItemType
+ * @param s - schema object
+ * @param ctx - 上下文对象
+ * @returns 名称字符串
+ */
+export declare const nameForPredItem: (predItem: PredItemType, s: SchemaType, ctx: ctx) => string | null;
+/**
+ * @deprecated 请使用 nameForPredItem 代替
+ */
+export declare const nameForPredNode: (predItem: PredItemType, s: SchemaType, ctx: ctx) => string | null;

package/dist/logicform/{nameForPredNode.js → preds/nameForPredItem.js}

@@ -3,11 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.nameForPredNode = exports.nameForQuery = void 0;
+exports.nameForPredNode = exports.nameForPredItem = exports.nameForQuery = void 0;
 const moment_1 = __importDefault(require("moment"));
-const schema_utils_1 = require("../schema/schema.utils");
-const utils_1 = require("../custom-function/utils");
-const date_1 = require("../common/date");
+const schema_utils_1 = require("../../schema/schema.utils");
+const utils_1 = require("../../custom-function/utils");
+const date_1 = require("../../common/date");
 // ============== 辅助函数 ==============
 const getPropertyName = (property) => {
     var _a;
@@ -627,35 +627,35 @@ const nameForQuery = (query, schema, schemas) => {
     return name;
 };
 exports.nameForQuery = nameForQuery;
-// ============== nameForPredNode ==============
+// ============== nameForPredItem ==============
 /**
- * 给pred node起名, normalize阶段用到
- * @param predNode - PredItemType
+ * 给pred item起名, normalize阶段用到
+ * @param predItem - PredItemType
  * @param s - schema object
  * @param ctx - 上下文对象
  * @returns 名称字符串
  */
-const nameForPredNode = (predNode, s, ctx) => {
+const nameForPredItem = (predItem, s, ctx) => {
     var _a, _b, _c, _d;
     const { schemas, customFunctions, locale = 'zh-CN' } = ctx;
-    if (typeof predNode !== 'object')
+    if (typeof predItem !== 'object')
         return null;
-    const schema = predNode.schema ? schemas[predNode.schema] : s;
+    const schema = predItem.schema ? schemas[predItem.schema] : s;
     let name = '';
     // query
-    if (predNode.query) {
-        name += (0, exports.nameForQuery)(predNode.query, schema, schemas);
+    if (predItem.query) {
+        name += (0, exports.nameForQuery)(predItem.query, schema, schemas);
     }
     // operator
     let useAggKey = false;
-    if (predNode.query && schema.agg_key && schema.agg_key.key in predNode.query) {
+    if (predItem.query && schema.agg_key && schema.agg_key.key in predItem.query) {
         let keyName;
-        if (typeof predNode.query[schema.agg_key.key] === 'object' &&
-            predNode.query[schema.agg_key.key].query) {
-            keyName = Object.values(predNode.query[schema.agg_key.key].query)[0];
+        if (typeof predItem.query[schema.agg_key.key] === 'object' &&
+            predItem.query[schema.agg_key.key].query) {
+            keyName = Object.values(predItem.query[schema.agg_key.key].query)[0];
         }
         else {
-            keyName = predNode.query[schema.agg_key.key];
+            keyName = predItem.query[schema.agg_key.key];
         }
         useAggKey = true;
         let onlyValue = keyName;
@@ -665,26 +665,26 @@ const nameForPredNode = (predNode, s, ctx) => {
         name += onlyValue;
     }
     let defaultNameCalled = false;
-    if (predNode.operator) {
-        const func = (0, utils_1.findOneCustomFunction)(predNode.schema || schema._id, predNode.operator, customFunctions);
+    if (predItem.operator) {
+        const func = (0, utils_1.findOneCustomFunction)(predItem.schema || schema._id, predItem.operator, customFunctions);
         if (!func) {
-            throw new Error(`未注册的函数：${predNode.operator}`);
+            throw new Error(`未注册的函数：${predItem.operator}`);
         }
         let basePredName = null;
         let baseProperty = null;
-        if (typeof predNode.pred === 'object') {
-            basePredName = (0, exports.nameForPredNode)(predNode.pred, schema, ctx);
+        if (typeof predItem.pred === 'object') {
+            basePredName = (0, exports.nameForPredItem)(predItem.pred, schema, ctx);
         }
-        else if (predNode.pred) {
-            baseProperty = (0, schema_utils_1.findPropertyByName)(schema._id, predNode.pred, schemas);
+        else if (predItem.pred) {
+            baseProperty = (0, schema_utils_1.findPropertyByName)(schema._id, predItem.pred, schemas);
             if (baseProperty) {
                 basePredName = getPropertyName(baseProperty);
             }
             else {
-                basePredName = predNode.pred;
+                basePredName = predItem.pred;
             }
         }
-        if (predNode.by) {
+        if (predItem.by) {
             const addNameForByItem = (byItem) => {
                 if ([
                     '$year',
@@ -734,28 +734,28 @@ const nameForPredNode = (predNode, s, ctx) => {
                     name += byItem;
                 }
             };
-            if (typeof predNode.by === 'string') {
-                addNameForByItem(predNode.by);
+            if (typeof predItem.by === 'string') {
+                addNameForByItem(predItem.by);
             }
-            else if (Array.isArray(predNode.by)) {
-                predNode.by.forEach((byItem) => addNameForByItem(byItem));
+            else if (Array.isArray(predItem.by)) {
+                predItem.by.forEach((byItem) => addNameForByItem(byItem));
             }
             name += zhCNToOthers('均', locale);
         }
         if (func && func.defaultName) {
             if (func.name === '$sql') {
-                name += func.defaultName(Object.assign(Object.assign({}, predNode), { schema }), locale, Object.assign(Object.assign({}, ctx), { nameForPredNode: exports.nameForPredNode }));
+                name += func.defaultName(Object.assign(Object.assign({}, predItem), { schema }), locale, Object.assign(Object.assign({}, ctx), { nameForPredItem: exports.nameForPredItem }));
             }
             else if (func.name === '$count_recent' || func.name === '$count_repeat' || func.name === '$sql') {
-                name = func.defaultName(Object.assign(Object.assign({}, predNode), { name: basePredName, schema }), locale, Object.assign(Object.assign({}, ctx), { nameForPredNode: exports.nameForPredNode }));
+                name = func.defaultName(Object.assign(Object.assign({}, predItem), { name: basePredName, schema }), locale, Object.assign(Object.assign({}, ctx), { nameForPredItem: exports.nameForPredItem }));
             }
-            else if (!(useAggKey && predNode.pred === ((_a = schema.agg_key) === null || _a === void 0 ? void 0 : _a.value))) {
-                name += func.defaultName(Object.assign(Object.assign(Object.assign({}, predNode), (baseProperty || {})), { name: basePredName, schema }), locale, Object.assign(Object.assign({}, ctx), { nameForPredNode: exports.nameForPredNode }));
+            else if (!(useAggKey && predItem.pred === ((_a = schema.agg_key) === null || _a === void 0 ? void 0 : _a.value))) {
+                name += func.defaultName(Object.assign(Object.assign(Object.assign({}, predItem), (baseProperty || {})), { name: basePredName, schema }), locale, Object.assign(Object.assign({}, ctx), { nameForPredItem: exports.nameForPredItem }));
             }
             defaultNameCalled = true;
         }
         else {
-            switch (predNode.operator) {
+            switch (predItem.operator) {
                 case '$hour':
                     name += `${zhCNToOthers('每小时', locale)}${basePredName}`;
                     break;
@@ -800,51 +800,51 @@ const nameForPredNode = (predNode, s, ctx) => {
                         $splm: '环期',
                         $splw: '周环期',
                     };
-                    if (map[predNode.operator] === '环期') {
+                    if (map[predItem.operator] === '环期') {
                         name += `${zhCNToOthers('上期', locale)}${basePredName}`;
                     }
-                    else if (map[predNode.operator] === '同期') {
-                        name += `${zhCNToOthers(map[predNode.operator], locale)}${basePredName}`;
+                    else if (map[predItem.operator] === '同期') {
+                        name += `${zhCNToOthers(map[predItem.operator], locale)}${basePredName}`;
                     }
                     else {
-                        name += `${basePredName}${zhCNToOthers(map[predNode.operator], locale)}`;
+                        name += `${basePredName}${zhCNToOthers(map[predItem.operator], locale)}`;
                     }
-                    if (predNode.params) {
-                        if ((_b = predNode.params[0]) === null || _b === void 0 ? void 0 : _b.time) {
+                    if (predItem.params) {
+                        if ((_b = predItem.params[0]) === null || _b === void 0 ? void 0 : _b.time) {
                             const timestampProp = (0, schema_utils_1.findTimestampLikeProperty)(schema);
                             if (timestampProp) {
                                 name += (0, exports.nameForQuery)({
-                                    [timestampProp.name]: predNode.params[0].time,
+                                    [timestampProp.name]: predItem.params[0].time,
                                 }, schema, schemas);
                             }
                         }
-                        if (((_c = predNode.params[0]) === null || _c === void 0 ? void 0 : _c.by) === 'lunar') {
+                        if (((_c = predItem.params[0]) === null || _c === void 0 ? void 0 : _c.by) === 'lunar') {
                             name += zhCNToOthers('按农历', locale);
                         }
-                        else if (((_d = predNode.params[0]) === null || _d === void 0 ? void 0 : _d.by) === 'weekday') {
+                        else if (((_d = predItem.params[0]) === null || _d === void 0 ? void 0 : _d.by) === 'weekday') {
                             name += zhCNToOthers('按星期', locale);
                         }
                     }
                     break;
                 }
                 case '$percentage':
-                    if (predNode.pred) {
-                        if (typeof predNode.pred === 'object') {
-                            name += (0, exports.nameForPredNode)(predNode.pred, schema, ctx);
+                    if (predItem.pred) {
+                        if (typeof predItem.pred === 'object') {
+                            name += (0, exports.nameForPredItem)(predItem.pred, schema, ctx);
                         }
                         else {
-                            name += predNode.pred;
+                            name += predItem.pred;
                         }
                     }
                     name += zhCNToOthers('占比', locale);
                     break;
                 case '$uniq':
-                    if (predNode.pred) {
-                        if (typeof predNode.pred === 'object') {
-                            name += (0, exports.nameForPredNode)(predNode.pred, schema, ctx);
+                    if (predItem.pred) {
+                        if (typeof predItem.pred === 'object') {
+                            name += (0, exports.nameForPredItem)(predItem.pred, schema, ctx);
                         }
                         else {
-                            name += predNode.pred;
+                            name += predItem.pred;
                         }
                     }
                     name += zhCNToOthers('数量', locale);
@@ -877,23 +877,23 @@ const nameForPredNode = (predNode, s, ctx) => {
                     name += `${basePredName}${zhCNToOthers('段', locale)}`;
                     break;
                 default:
-                    name += predNode.operator;
+                    name += predItem.operator;
                     break;
             }
         }
     }
-    else if (predNode.pred) {
-        if (predNode.pred === '*') {
+    else if (predItem.pred) {
+        if (predItem.pred === '*') {
             return null;
         }
-        name += predNode.pred;
+        name += predItem.pred;
     }
     // level
-    if (!defaultNameCalled && predNode.level) {
-        name += `(${predNode.level})`;
+    if (!defaultNameCalled && predItem.level) {
+        name += `(${predItem.level})`;
     }
     // accumulate
-    if (predNode.accumulate) {
+    if (predItem.accumulate) {
         if (locale.startsWith('en')) {
             // do nothing
         }
@@ -904,4 +904,8 @@ const nameForPredNode = (predNode, s, ctx) => {
     // feat: name 不能有下划线
     return name.replace(/_/g, '');
 };
-exports.nameForPredNode = nameForPredNode;
+exports.nameForPredItem = nameForPredItem;
+/**
+ * @deprecated 请使用 nameForPredItem 代替
+ */
+exports.nameForPredNode = exports.nameForPredItem;

package/dist/logicform/preds/propertyForPredItem.d.ts

@@ -0,0 +1,27 @@
+import { SchemaType } from '../../schema/schema';
+import { PropertyType } from '../../schema/property';
+import { PredItemType, LogicformType } from '../logicform';
+import { ctx } from './nameForPredItem';
+export interface PropertyForPredItemCtx extends ctx {
+    logicform: LogicformType;
+    permissions?: Record<string, {
+        blacklist?: string[];
+        whitelist?: string[];
+    }>;
+}
+export interface PredItemProperty extends PropertyType {
+    baseProperty?: PropertyType | null;
+    auth?: boolean;
+    is_delta?: boolean;
+    components?: any[];
+    componentProperties?: (PredItemProperty | undefined)[];
+    from?: string;
+}
+/**
+ * 根据PredItemType生成对应的PropertyType
+ * @param predItem - PredItemType
+ * @param s - schema object
+ * @param ctx - 上下文对象
+ * @returns PropertyType或undefined
+ */
+export declare const propertyForPredItem: (predItem: PredItemType, s: SchemaType, ctx: PropertyForPredItemCtx) => PredItemProperty | undefined;

package/dist/logicform/preds/propertyForPredItem.js

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propertyForPredItem = void 0;
+const schema_utils_1 = require("../../schema/schema.utils");
+const utils_1 = require("../../custom-function/utils");
+const nameForPredItem_1 = require("./nameForPredItem");
+// ============== 辅助函数 ==============
+/**
+ * 根据operator获取property的类型信息
+ */
+const getPropertyTypeFromOperator = (operator, baseProperty) => {
+    // 百分比类算子
+    if (['$yoy', '$mom', '$wow', '$qoq', '$percentage'].includes(operator)) {
+        return {
+            type: 'percentage',
+            primal_type: 'number',
+        };
+    }
+    // 差值类算子
+    if (['$yoyd', '$momd'].includes(operator)) {
+        return {
+            type: (baseProperty === null || baseProperty === void 0 ? void 0 : baseProperty.type) || 'number',
+            primal_type: 'number',
+        };
+    }
+    // 计数类算子
+    if (['$count', '$uniq', '$count_recent', '$count_repeat'].includes(operator)) {
+        return {
+            type: 'int',
+            primal_type: 'number',
+        };
+    }
+    // 日期提取类算子
+    if (['$year', '$month', '$day', '$hour', '$minute', '$second', '$week', '$weekday', '$quarter'].includes(operator)) {
+        return {
+            type: 'int',
+            primal_type: 'number',
+        };
+    }
+    // 平均值类算子，保持原类型
+    if (['$avg', '$dailyavg', '$monthlyavg', '$weeklyavg'].includes(operator)) {
+        return {
+            type: (baseProperty === null || baseProperty === void 0 ? void 0 : baseProperty.type) || 'number',
+            primal_type: 'number',
+            is_additive: false, // 平均值不可加
+        };
+    }
+    // 求和/最大/最小等，保持原类型
+    if (['$sum', '$max', '$min'].includes(operator)) {
+        return {
+            type: (baseProperty === null || baseProperty === void 0 ? void 0 : baseProperty.type) || 'number',
+            primal_type: 'number',
+        };
+    }
+    // 分段算子
+    if (operator === '$piecewise') {
+        return {
+            type: 'category',
+            primal_type: 'string',
+            is_categorical: true,
+        };
+    }
+    // 默认返回number类型
+    return {
+        type: 'number',
+        primal_type: 'number',
+    };
+};
+/**
+ * 从PredItemType生成PropertyType
+ */
+const getPropertyFromPredItem = (predItem, ctx) => {
+    const { schemas, customFunctions, logicform } = ctx;
+    const schemaID = predItem.schema || logicform.schema;
+    const schema = schemas[schemaID];
+    // 尝试找到自定义函数
+    const func = predItem.operator
+        ? (0, utils_1.findOneCustomFunction)(schemaID, predItem.operator, customFunctions)
+        : null;
+    // 如果自定义函数有genProperty方法，使用它
+    if (func && func.genProperty) {
+        return func.genProperty(predItem, {
+            schema,
+            schemas,
+            logicform,
+        });
+    }
+    // 找到基础property
+    let baseProperty = null;
+    if (predItem.pred && typeof predItem.pred === 'string') {
+        baseProperty = (0, schema_utils_1.findPropertyByName)(schemaID, predItem.pred, schemas);
+    }
+    // 根据operator推断类型
+    const typeInfo = predItem.operator
+        ? getPropertyTypeFromOperator(predItem.operator, baseProperty)
+        : {};
+    return Object.assign(Object.assign({ name: predItem.name || '' }, typeInfo), { _sid: predItem.name || '', _id: predItem.name || '', constraints: {}, ui: (baseProperty === null || baseProperty === void 0 ? void 0 : baseProperty.ui) || {} });
+};
+// ============== propertyForPredItem ==============
+/**
+ * 根据PredItemType生成对应的PropertyType
+ * @param predItem - PredItemType
+ * @param s - schema object
+ * @param ctx - 上下文对象
+ * @returns PropertyType或undefined
+ */
+const propertyForPredItem = (predItem, s, ctx) => {
+    const { schemas, customFunctions, logicform, permissions } = ctx;
+    // 特殊情况处理
+    if (predItem.pred === '*')
+        return undefined;
+    if (!predItem.name)
+        throw new Error('pred item必须要有name');
+    if (predItem.name === '_id')
+        return undefined;
+    const schema = predItem.schema ? schemas[predItem.schema] : s;
+    let targetProperty;
+    let baseProperty = null;
+    // 找基础property
+    if (predItem.pred) {
+        if (typeof predItem.pred === 'string') {
+            baseProperty = (0, schema_utils_1.findPropertyByName)(schema._id, predItem.pred, schemas);
+        }
+        else if (typeof predItem.pred === 'object') {
+            // 针对嵌套pred时，内层pred没有pred字段导致无法找到prop的场景
+            const innerProperty = (0, exports.propertyForPredItem)(Object.assign({ schema: schema._id }, predItem.pred), schema, ctx);
+            if (innerProperty) {
+                baseProperty = innerProperty;
+            }
+        }
+        if (baseProperty) {
+            baseProperty.from = schema._id;
+        }
+    }
+    // 生成targetProperty
+    if (!predItem.operator && predItem.pred) {
+        // 没有operator，直接使用baseProperty
+        targetProperty = Object.assign(Object.assign({}, baseProperty), { name: predItem.name });
+    }
+    else {
+        // 有operator，通过operator推断property
+        const generatedProperty = getPropertyFromPredItem(Object.assign(Object.assign({}, predItem), { schema: predItem.schema || schema._id }), ctx);
+        targetProperty = Object.assign({ _sid: predItem.name, _id: predItem.name, name: predItem.name, type: 'number', primal_type: 'number', constraints: {}, ui: {} }, generatedProperty);
+    }
+    targetProperty.baseProperty = baseProperty;
+    // 处理ref和schema
+    if (targetProperty.primal_type !== 'object') {
+        delete targetProperty.ref;
+        delete targetProperty.schema;
+    }
+    if (targetProperty.ref && schemas[targetProperty.ref]) {
+        targetProperty.schema = JSON.parse(JSON.stringify(schemas[targetProperty.ref]));
+    }
+    // 权限处理
+    targetProperty.auth = true;
+    const schemaID = (baseProperty === null || baseProperty === void 0 ? void 0 : baseProperty.schemaID) || logicform.schema;
+    if (baseProperty && permissions && permissions[schemaID]) {
+        const blacklist = permissions[schemaID].blacklist || [];
+        if (blacklist.find((black) => black === baseProperty.name)) {
+            targetProperty.auth = false;
+        }
+        if (permissions[schemaID].whitelist && permissions[schemaID].whitelist.length > 0) {
+            if (!permissions[schemaID].whitelist.find((white) => white === baseProperty.name)) {
+                targetProperty.auth = false;
+            }
+        }
+    }
+    // 检查groupby权限
+    const isGroupbyPred = logicform.groupby && logicform.groupby.find((g) => g.name === predItem.name);
+    if (!targetProperty.auth && isGroupbyPred) {
+        throw new Error(`您无权限查看：${targetProperty.name} 相关数据`);
+    }
+    // 处理components
+    const func = predItem.operator
+        ? (0, utils_1.findOneCustomFunction)(predItem.schema || logicform.schema, predItem.operator, customFunctions)
+        : null;
+    if (func && func.genComponents) {
+        let genComponentsFn = func.genComponents;
+        if (typeof genComponentsFn === 'string') {
+            genComponentsFn = new Function(`return ${genComponentsFn}`)();
+        }
+        targetProperty.components = genComponentsFn(predItem, {
+            schema,
+            logicform: JSON.parse(JSON.stringify(logicform)),
+            nameForPredItem: nameForPredItem_1.nameForPredItem,
+            schemas,
+            customFunctions,
+        });
+        // 处理name_postfix和name_prefix
+        if (predItem.name_postfix) {
+            targetProperty.components.forEach((c) => {
+                c.name = `${c.name}${predItem.name_postfix}`;
+            });
+        }
+        else if (predItem.name_prefix) {
+            targetProperty.components.forEach((c) => {
+                c.name = `${predItem.name_prefix}${c.name}`;
+            });
+        }
+    }
+    // 处理差值类operator
+    if (predItem.operator && predItem.operator.match(/^\$[a-z]o[a-z]d$/)) {
+        targetProperty.is_delta = true;
+    }
+    // 除法导致不可加
+    if (predItem.by) {
+        targetProperty.is_additive = false;
+    }
+    // 递归处理componentProperties
+    if (targetProperty.components) {
+        targetProperty.componentProperties = targetProperty.components.map((c) => {
+            try {
+                if (!c.name) {
+                    c.name = (0, nameForPredItem_1.nameForPredItem)(c, schema, ctx);
+                }
+                return (0, exports.propertyForPredItem)(c, schema, ctx);
+            }
+            catch (error) {
+                console.error('in propertyForPredItem componentProperties', error);
+                return undefined;
+            }
+        });
+    }
+    // 清理不需要的字段
+    delete targetProperty.run;
+    delete targetProperty.genComponents;
+    delete targetProperty.mergeComponents;
+    delete targetProperty.shouldSplitGroupby;
+    return targetProperty;
+};
+exports.propertyForPredItem = propertyForPredItem;

package/dist/schema/property.d.ts

@@ -49,7 +49,11 @@ export interface PropertyTypeDraft {
         avg?: number;
         distincts?: any[];
     };
-    cases?: any[];
+    cases?: {
+        name: string;
+        syno?: string[];
+        sql?: string;
+    }[];
     ui?: {
         name?: boolean;
         title?: string;
@@ -75,6 +79,8 @@ export interface PropertyTypeDraft {
     };
     recommend_kpis?: any[];
     components?: any[];
+    quantifier?: string;
+    quantifiers?: Record<string, number>;
 }
 export interface PropertyType extends Omit<PropertyTypeDraft, '_sid' | '_id' | 'constraints' | 'primal_type' | 'ui'>, Required<Pick<PropertyTypeDraft, '_sid' | '_id' | 'constraints' | 'primal_type' | 'ui'>> {
     schemaID?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "semanticdb-core",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [

package/dist/logicform/nameForPredNode.d.ts

@@ -1,20 +0,0 @@
-import { SchemaType } from '../schema/schema';
-import { PredItemType } from './logicform';
-import { QueryType } from './types/query';
-export interface ctx {
-    schemas: Record<string, SchemaType>;
-    customFunctions: Record<string, any>;
-    locale?: string;
-}
-/**
- * 给Query起名
- */
-export declare const nameForQuery: (query: QueryType, schema: SchemaType, schemas: Record<string, SchemaType>) => string;
-/**
- * 给pred node起名, normalize阶段用到
- * @param predNode - PredItemType
- * @param s - schema object
- * @param ctx - 上下文对象
- * @returns 名称字符串
- */
-export declare const nameForPredNode: (predNode: PredItemType, s: SchemaType, ctx: ctx) => string | null;