semanticdb-core 1.1.46 → 1.1.48

package/dist/logicform/explainLogicform.js

@@ -68,6 +68,40 @@ const stringifyExplainValue = (value, schemas) => {
     }
     return stringifyJson(value);
 };
+const LOGICAL_OPERATOR_LABELS = {
+    $and: '且',
+    $or: '或',
+};
+const stripExplainKeyPrefix = (segment, key) => {
+    const keyPrefix = `${key} `;
+    if (segment.startsWith(keyPrefix)) {
+        return segment.slice(keyPrefix.length);
+    }
+    return segment;
+};
+const explainLogicalComparedValue = (key, operator, operatorValue, schemas) => {
+    if (!Array.isArray(operatorValue)) {
+        return `${key} ${operator} ${stringifyExplainValue(operatorValue, schemas)}`;
+    }
+    const explainedSegments = operatorValue
+        .map((item, index) => {
+        if (isCompareOperatorObject(item)) {
+            const comparedValue = explainComparedValue(key, item, schemas);
+            const normalizedValue = stripExplainKeyPrefix(comparedValue, key);
+            return `(${normalizedValue})`;
+        }
+        return `(= ${stringifyExplainValue(item, schemas)})`;
+    })
+        .filter((segment) => segment.length > 0);
+    if (explainedSegments.length === 0) {
+        return `${key} ${operator} []`;
+    }
+    const [firstSegment, ...restSegments] = explainedSegments;
+    const normalizedFirstSegment = firstSegment.startsWith('(= ')
+        ? `${key} = (${firstSegment.slice(3, -1)})`
+        : `${key} ${firstSegment}`;
+    return [normalizedFirstSegment, ...restSegments].join(` ${LOGICAL_OPERATOR_LABELS[operator]} `);
+};
 const explainSingleComparedValue = (key, operator, operatorValue, schemas) => {
     if ((operator === '$in' || operator === '$nin') &&
         Array.isArray(operatorValue) &&
@@ -111,6 +145,9 @@ const explainSingleComparedValue = (key, operator, operatorValue, schemas) => {
     if (operator === '$contains') {
         return `${key} 包含 ${stringifyExplainValue(operatorValue, schemas)}`;
     }
+    if (operator === '$and' || operator === '$or') {
+        return explainLogicalComparedValue(key, operator, operatorValue, schemas);
+    }
     return `${key} ${operator} ${stringifyExplainValue(operatorValue, schemas)}`;
 };
 const explainNegatedComparedValue = (key, value, schemas) => {
@@ -168,6 +205,28 @@ const explainComparedValue = (key, value, schemas) => {
     });
     return segments.join(' 且 ');
 };
+const explainTopLevelLogicalQuery = (operator, operatorValue, includeValue, schemas) => {
+    if (!Array.isArray(operatorValue)) {
+        return `${operator} ${stringifyExplainValue(operatorValue, schemas)}`;
+    }
+    const explainedSegments = operatorValue
+        .map((item) => {
+        if (!isPlainObject(item)) {
+            return stringifyExplainValue(item, schemas);
+        }
+        const itemValues = explainFilterLikeQuery(item, '', includeValue, schemas).values;
+        if (itemValues.length === 0) {
+            return '';
+        }
+        return itemValues.join('、');
+    })
+        .filter((segment) => segment.length > 0)
+        .map((segment) => `(${segment})`);
+    if (explainedSegments.length === 0) {
+        return `${operator} []`;
+    }
+    return explainedSegments.join(` ${LOGICAL_OPERATOR_LABELS[operator]} `);
+};
 const getEntityIdFromValue = (value) => {
     if (!value || typeof value !== 'object' || Array.isArray(value)) {
         return undefined;
@@ -214,6 +273,9 @@ const explainFilterLikeQuery = (query, prefix = '筛选', includeValue = false,
     const values = Object.entries(query)
         .filter(([k]) => includeValue || k !== 'entity_id')
         .map(([k, v]) => {
+        if (k === '$and' || k === '$or') {
+            return explainTopLevelLogicalQuery(k, v, includeValue, schemas);
+        }
         const key = formatExplainKey(k);
         if (includeValue) {
             if (k === 'entity_id') {

package/dist/logicform/types/query.d.ts

@@ -2,9 +2,26 @@ import { LogicformType } from '../logicform';
 import { DateValue } from './date';
 export declare type CompareOperator = '$eq' | '$gt' | '$gte' | '$lt' | '$lte' | '$ne' | '$in' | '$nin' | '$exists' | '$regex' | '$contains' | '$options' | '$and' | '$or';
 export declare type QueryValueType = null | string | number | boolean | DateValue | LogicformType | string[] | number[] | boolean[] | DateValue[] | LogicformType[];
+export declare type QueryLogicalOperand = QueryValueType | QueryValueTypeWithCompareOperator;
 export declare type QueryValueTypeWithCompareOperator = Partial<{
-    [K in CompareOperator]: QueryValueType;
+    $eq: QueryValueType;
+    $gt: QueryValueType;
+    $gte: QueryValueType;
+    $lt: QueryValueType;
+    $lte: QueryValueType;
+    $ne: QueryValueType;
+    $in: QueryValueType;
+    $nin: QueryValueType;
+    $exists: QueryValueType;
+    $regex: QueryValueType;
+    $contains: QueryValueType;
+    $options: QueryValueType;
+    $and: QueryLogicalOperand[];
+    $or: QueryLogicalOperand[];
 }> & {
     schema?: never;
 };
-export declare type QueryType = Record<string, QueryValueType | QueryValueTypeWithCompareOperator | QueryType[] | undefined>;
+export declare type QueryType = Record<string, QueryValueType | QueryValueTypeWithCompareOperator | QueryType[] | undefined> & Partial<{
+    $and: QueryType[];
+    $or: QueryType[];
+}>;

package/package.json

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