@flowgram.ai/form-materials 0.4.13 → 0.4.14

package/dist/cjs/components/code-editor/theme/light.js

@@ -24,51 +24,68 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
+    colors: ()=>colors,
     lightTheme: ()=>lightTheme
 });
 const preset_code_namespaceObject = require("@flowgram.ai/coze-editor/preset-code");
 const colors = {
-    background: '#FFFFFF',
-    comment: '#6B7280',
-    key: '#2563EB',
-    variable: '#DC2626',
-    string: '#059669',
-    number: '#EA580C',
-    boolean: '#7C3AED',
-    null: '#7C3AED',
-    separator: '#374151'
+    background: '#f4f5f5',
+    foreground: '#444d56',
+    selection: '#0366d625',
+    cursor: '#044289',
+    dropdownBackground: '#fff',
+    dropdownBorder: '#e1e4e8',
+    activeLine: '#c6c6c622',
+    matchingBracket: '#34d05840',
+    keyword: '#d73a49',
+    storage: '#d73a49',
+    variable: '#e36209',
+    parameter: '#24292e',
+    function: '#005cc5',
+    string: '#032f62',
+    constant: '#005cc5',
+    type: '#005cc5',
+    class: '#6f42c1',
+    number: '#005cc5',
+    comment: '#6a737d',
+    heading: '#005cc5',
+    invalid: '#cb2431',
+    regexp: '#032f62'
 };
 const lightTheme = (0, preset_code_namespaceObject.createTheme)({
     variant: 'light',
     settings: {
-        background: '#FFFFFF',
-        foreground: '#1F2937',
-        caret: '#2563EB',
-        selection: '#E5E7EB',
-        gutterBackground: '#F9FAFB',
-        gutterForeground: '#6B7280',
+        background: colors.background,
+        foreground: colors.foreground,
+        caret: colors.cursor,
+        selection: colors.selection,
+        gutterBackground: colors.background,
+        gutterForeground: colors.foreground,
         gutterBorderColor: 'transparent',
         gutterBorderWidth: 0,
-        lineHighlight: '#F3F4F680',
+        lineHighlight: colors.background,
         bracketColors: [
             '#F59E0B',
             '#8B5CF6',
             '#06B6D4'
         ],
         tooltip: {
-            backgroundColor: '#FFFFFF',
-            color: '#1F2937',
-            border: '1px solid #E5E7EB',
-            boxShadow: '0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06)'
+            backgroundColor: colors.dropdownBackground,
+            color: colors.foreground,
+            border: 'none',
+            boxShadow: '0 0 1px rgba(0, 0, 0, .3), 0 4px 14px rgba(0, 0, 0, .1)!important',
+            maxWidth: '400px'
         },
         link: {
-            color: '#2563EB'
+            color: '#2563EB',
+            caret: colors.cursor
         },
         completionItemHover: {
             backgroundColor: '#F3F4F6'
         },
         completionItemSelected: {
-            backgroundColor: '#E5E7EB'
+            backgroundColor: colors.selection,
+            color: colors.foreground
         },
         completionItemIcon: {
             color: '#4B5563'
@@ -85,109 +102,141 @@ const lightTheme = (0, preset_code_namespaceObject.createTheme)({
     },
     styles: [
         {
-            tag: preset_code_namespaceObject.tags.comment,
-            color: colors.comment
+            tag: preset_code_namespaceObject.tags.keyword,
+            color: colors.keyword
         },
         {
             tag: [
-                preset_code_namespaceObject.tags.propertyName
+                preset_code_namespaceObject.tags.name,
+                preset_code_namespaceObject.tags.deleted,
+                preset_code_namespaceObject.tags.character,
+                preset_code_namespaceObject.tags.macroName
             ],
-            color: colors.key
+            color: colors.variable
         },
         {
             tag: [
-                preset_code_namespaceObject.tags.variableName
+                preset_code_namespaceObject.tags.propertyName
             ],
-            color: colors.variable
+            color: colors.function
         },
         {
             tag: [
-                preset_code_namespaceObject.tags.string
+                preset_code_namespaceObject.tags.processingInstruction,
+                preset_code_namespaceObject.tags.string,
+                preset_code_namespaceObject.tags.inserted,
+                preset_code_namespaceObject.tags.special(preset_code_namespaceObject.tags.string)
             ],
             color: colors.string
         },
         {
             tag: [
-                preset_code_namespaceObject.tags.number
+                preset_code_namespaceObject.tags["function"](preset_code_namespaceObject.tags.variableName),
+                preset_code_namespaceObject.tags.labelName
             ],
-            color: colors.number
+            color: colors.function
         },
         {
             tag: [
-                preset_code_namespaceObject.tags.bool
+                preset_code_namespaceObject.tags.color,
+                preset_code_namespaceObject.tags.constant(preset_code_namespaceObject.tags.name),
+                preset_code_namespaceObject.tags.standard(preset_code_namespaceObject.tags.name)
             ],
-            color: colors.boolean
+            color: colors.constant
         },
         {
             tag: [
-                preset_code_namespaceObject.tags["null"]
+                preset_code_namespaceObject.tags.definition(preset_code_namespaceObject.tags.name),
+                preset_code_namespaceObject.tags.separator
             ],
-            color: colors.null
+            color: colors.variable
         },
         {
             tag: [
-                preset_code_namespaceObject.tags.separator
+                preset_code_namespaceObject.tags.className
             ],
-            color: colors.separator
+            color: colors.class
         },
         {
             tag: [
-                preset_code_namespaceObject.tags.heading
+                preset_code_namespaceObject.tags.number,
+                preset_code_namespaceObject.tags.changed,
+                preset_code_namespaceObject.tags.annotation,
+                preset_code_namespaceObject.tags.modifier,
+                preset_code_namespaceObject.tags.self,
+                preset_code_namespaceObject.tags.namespace
             ],
-            color: '#2563EB'
+            color: colors.number
         },
         {
             tag: [
-                preset_code_namespaceObject.tags.processingInstruction
+                preset_code_namespaceObject.tags.typeName
             ],
-            color: '#2563EB'
+            color: colors.type,
+            fontStyle: colors.type
         },
         {
             tag: [
-                preset_code_namespaceObject.tags.definitionKeyword
+                preset_code_namespaceObject.tags.operator,
+                preset_code_namespaceObject.tags.operatorKeyword
             ],
-            color: '#9333EA'
+            color: colors.keyword
         },
         {
             tag: [
-                preset_code_namespaceObject.tags.modifier
+                preset_code_namespaceObject.tags.url,
+                preset_code_namespaceObject.tags.escape,
+                preset_code_namespaceObject.tags.regexp,
+                preset_code_namespaceObject.tags.link
             ],
-            color: '#9333EA'
+            color: colors.regexp
         },
         {
             tag: [
-                preset_code_namespaceObject.tags.controlKeyword
+                preset_code_namespaceObject.tags.meta,
+                preset_code_namespaceObject.tags.comment
             ],
-            color: '#9333EA'
+            color: colors.comment
         },
         {
-            tag: [
-                preset_code_namespaceObject.tags.operatorKeyword
-            ],
-            color: '#9333EA'
+            tag: preset_code_namespaceObject.tags.strong,
+            fontWeight: 'bold'
         },
         {
-            tag: [
-                preset_code_namespaceObject.tags.standard(preset_code_namespaceObject.tags.variableName)
-            ],
-            color: '#059669'
+            tag: preset_code_namespaceObject.tags.emphasis,
+            fontStyle: 'italic'
         },
         {
-            tag: [
-                preset_code_namespaceObject.tags.attributeName
-            ],
-            color: '#EA580C'
+            tag: preset_code_namespaceObject.tags.link,
+            textDecoration: 'underline'
+        },
+        {
+            tag: preset_code_namespaceObject.tags.heading,
+            fontWeight: 'bold',
+            color: colors.heading
         },
         {
             tag: [
-                preset_code_namespaceObject.tags.special(preset_code_namespaceObject.tags.string)
+                preset_code_namespaceObject.tags.atom,
+                preset_code_namespaceObject.tags.bool,
+                preset_code_namespaceObject.tags.special(preset_code_namespaceObject.tags.variableName)
             ],
-            color: '#2563EB'
+            color: colors.variable
+        },
+        {
+            tag: preset_code_namespaceObject.tags.invalid,
+            color: colors.invalid
+        },
+        {
+            tag: preset_code_namespaceObject.tags.strikethrough,
+            textDecoration: 'line-through'
         }
     ]
 });
+exports.colors = __webpack_exports__.colors;
 exports.lightTheme = __webpack_exports__.lightTheme;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "colors",
     "lightTheme"
 ].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
 Object.defineProperty(exports, '__esModule', {

package/dist/cjs/components/condition-context/context.js

@@ -0,0 +1,59 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    ConditionProvider: ()=>ConditionProvider,
+    ConditionContext: ()=>ConditionContext,
+    useConditionContext: ()=>useConditionContext
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const external_react_namespaceObject = require("react");
+const external_op_js_namespaceObject = require("./op.js");
+const ConditionContext = /*#__PURE__*/ (0, external_react_namespaceObject.createContext)({
+    rules: {},
+    ops: external_op_js_namespaceObject.defaultConditionOpConfigs
+});
+const ConditionProvider = (props)=>{
+    const { rules, ops } = props;
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(ConditionContext.Provider, {
+        value: {
+            rules,
+            ops
+        },
+        children: props.children
+    });
+};
+const useConditionContext = ()=>(0, external_react_namespaceObject.useContext)(ConditionContext);
+exports.ConditionContext = __webpack_exports__.ConditionContext;
+exports.ConditionProvider = __webpack_exports__.ConditionProvider;
+exports.useConditionContext = __webpack_exports__.useConditionContext;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "ConditionContext",
+    "ConditionProvider",
+    "useConditionContext"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/components/condition-context/hooks/use-condition.js

@@ -0,0 +1,97 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    useCondition: ()=>useCondition
+});
+const external_react_namespaceObject = require("react");
+const editor_namespaceObject = require("@flowgram.ai/editor");
+const index_js_namespaceObject = require("../../../plugins/index.js");
+const external_context_js_namespaceObject = require("../context.js");
+function useCondition({ leftSchema, operator, ruleConfig }) {
+    const typeManager = (0, index_js_namespaceObject.useTypeManager)();
+    const { rules: contextRules, ops: contextOps } = (0, external_context_js_namespaceObject.useConditionContext)();
+    const userRules = (0, external_react_namespaceObject.useMemo)(()=>ruleConfig?.rules || contextRules || {}, [
+        contextRules,
+        ruleConfig?.rules
+    ]);
+    const allOps = (0, external_react_namespaceObject.useMemo)(()=>ruleConfig?.ops || contextOps || {}, [
+        contextOps,
+        ruleConfig?.ops
+    ]);
+    const config = (0, external_react_namespaceObject.useMemo)(()=>leftSchema ? typeManager.getTypeBySchema(leftSchema) : void 0, [
+        leftSchema,
+        typeManager
+    ]);
+    const rule = (0, external_react_namespaceObject.useMemo)(()=>{
+        if (!config) return;
+        if (userRules[config.type]) return userRules[config.type];
+        if ('function' == typeof config.conditionRule) return config.conditionRule(leftSchema);
+        return config.conditionRule;
+    }, [
+        userRules,
+        leftSchema,
+        config
+    ]);
+    const opOptionList = (0, external_react_namespaceObject.useMemo)(()=>Object.keys(rule || {}).filter((_op)=>allOps[_op]).map((_op)=>({
+                ...allOps?.[_op] || {},
+                value: _op,
+                label: editor_namespaceObject.I18n.t(allOps?.[_op]?.label || _op)
+            })), [
+        rule,
+        allOps
+    ]);
+    const targetSchema = (0, external_react_namespaceObject.useMemo)(()=>{
+        const targetType = rule?.[operator || ''] || null;
+        if (!targetType) return;
+        if ('string' == typeof targetType) return {
+            type: targetType,
+            extra: {
+                weak: true
+            }
+        };
+        return targetType;
+    }, [
+        rule,
+        operator
+    ]);
+    const opConfig = (0, external_react_namespaceObject.useMemo)(()=>allOps[operator || ''], [
+        operator,
+        allOps
+    ]);
+    return {
+        rule,
+        opConfig,
+        opOptionList,
+        targetSchema
+    };
+}
+exports.useCondition = __webpack_exports__.useCondition;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "useCondition"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/components/condition-context/index.js

@@ -0,0 +1,47 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    ConditionPresetOp: ()=>external_op_js_namespaceObject.ConditionPresetOp,
+    useConditionContext: ()=>external_context_js_namespaceObject.useConditionContext,
+    ConditionProvider: ()=>external_context_js_namespaceObject.ConditionProvider,
+    useCondition: ()=>use_condition_js_namespaceObject.useCondition
+});
+const external_op_js_namespaceObject = require("./op.js");
+const external_context_js_namespaceObject = require("./context.js");
+const use_condition_js_namespaceObject = require("./hooks/use-condition.js");
+exports.ConditionPresetOp = __webpack_exports__.ConditionPresetOp;
+exports.ConditionProvider = __webpack_exports__.ConditionProvider;
+exports.useCondition = __webpack_exports__.useCondition;
+exports.useConditionContext = __webpack_exports__.useConditionContext;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "ConditionPresetOp",
+    "ConditionProvider",
+    "useCondition",
+    "useConditionContext"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/components/condition-context/op.js

@@ -0,0 +1,117 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    ConditionPresetOp: ()=>ConditionPresetOp,
+    defaultConditionOpConfigs: ()=>defaultConditionOpConfigs
+});
+var ConditionPresetOp = /*#__PURE__*/ function(ConditionPresetOp) {
+    ConditionPresetOp["EQ"] = "eq";
+    ConditionPresetOp["NEQ"] = "neq";
+    ConditionPresetOp["GT"] = "gt";
+    ConditionPresetOp["GTE"] = "gte";
+    ConditionPresetOp["LT"] = "lt";
+    ConditionPresetOp["LTE"] = "lte";
+    ConditionPresetOp["IN"] = "in";
+    ConditionPresetOp["NIN"] = "nin";
+    ConditionPresetOp["CONTAINS"] = "contains";
+    ConditionPresetOp["NOT_CONTAINS"] = "not_contains";
+    ConditionPresetOp["IS_EMPTY"] = "is_empty";
+    ConditionPresetOp["IS_NOT_EMPTY"] = "is_not_empty";
+    ConditionPresetOp["IS_TRUE"] = "is_true";
+    ConditionPresetOp["IS_FALSE"] = "is_false";
+    return ConditionPresetOp;
+}({});
+const defaultConditionOpConfigs = {
+    ["eq"]: {
+        label: 'Equal',
+        abbreviation: '='
+    },
+    ["neq"]: {
+        label: 'Not Equal',
+        abbreviation: "\u2260"
+    },
+    ["gt"]: {
+        label: 'Greater Than',
+        abbreviation: '>'
+    },
+    ["gte"]: {
+        label: 'Greater Than or Equal',
+        abbreviation: '>='
+    },
+    ["lt"]: {
+        label: 'Less Than',
+        abbreviation: '<'
+    },
+    ["lte"]: {
+        label: 'Less Than or Equal',
+        abbreviation: '<='
+    },
+    ["in"]: {
+        label: 'In',
+        abbreviation: "\u2208"
+    },
+    ["nin"]: {
+        label: 'Not In',
+        abbreviation: "\u2209"
+    },
+    ["contains"]: {
+        label: 'Contains',
+        abbreviation: "\u2287"
+    },
+    ["not_contains"]: {
+        label: 'Not Contains',
+        abbreviation: "\u2289"
+    },
+    ["is_empty"]: {
+        label: 'Is Empty',
+        abbreviation: '=',
+        rightDisplay: 'Empty'
+    },
+    ["is_not_empty"]: {
+        label: 'Is Not Empty',
+        abbreviation: "\u2260",
+        rightDisplay: 'Empty'
+    },
+    ["is_true"]: {
+        label: 'Is True',
+        abbreviation: '=',
+        rightDisplay: 'True'
+    },
+    ["is_false"]: {
+        label: 'Is False',
+        abbreviation: '=',
+        rightDisplay: 'False'
+    }
+};
+exports.ConditionPresetOp = __webpack_exports__.ConditionPresetOp;
+exports.defaultConditionOpConfigs = __webpack_exports__.defaultConditionOpConfigs;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "ConditionPresetOp",
+    "defaultConditionOpConfigs"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});