@flowgram.ai/form-materials 0.1.0-alpha.14 → 0.1.0-alpha.16

package/dist/cjs/plugins/json-schema-preset/type-definition/number.js

@@ -0,0 +1,82 @@
+"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__, {
+    numberRegistry: ()=>numberRegistry
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+require("react");
+const editor_namespaceObject = require("@flowgram.ai/editor");
+const semi_ui_namespaceObject = require("@douyinfe/semi-ui");
+const op_js_namespaceObject = require("../../../components/condition-context/op.js");
+const numberRegistry = {
+    type: 'number',
+    ConstantRenderer: (props)=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(semi_ui_namespaceObject.InputNumber, {
+            placeholder: editor_namespaceObject.I18n.t('Please Input Number'),
+            size: "small",
+            disabled: props.readonly,
+            hideButtons: true,
+            ...props
+        }),
+    conditionRule: {
+        [op_js_namespaceObject.ConditionPresetOp.EQ]: {
+            type: 'number'
+        },
+        [op_js_namespaceObject.ConditionPresetOp.NEQ]: {
+            type: 'number'
+        },
+        [op_js_namespaceObject.ConditionPresetOp.GT]: {
+            type: 'number'
+        },
+        [op_js_namespaceObject.ConditionPresetOp.GTE]: {
+            type: 'number'
+        },
+        [op_js_namespaceObject.ConditionPresetOp.LT]: {
+            type: 'number'
+        },
+        [op_js_namespaceObject.ConditionPresetOp.LTE]: {
+            type: 'number'
+        },
+        [op_js_namespaceObject.ConditionPresetOp.IN]: {
+            type: 'array',
+            extra: {
+                weak: true
+            }
+        },
+        [op_js_namespaceObject.ConditionPresetOp.NIN]: {
+            type: 'array',
+            extra: {
+                weak: true
+            }
+        }
+    }
+};
+exports.numberRegistry = __webpack_exports__.numberRegistry;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "numberRegistry"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/json-schema-preset/type-definition/object.js

@@ -0,0 +1,54 @@
+"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__, {
+    objectRegistry: ()=>objectRegistry
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+require("react");
+const editor_namespaceObject = require("@flowgram.ai/editor");
+const op_js_namespaceObject = require("../../../components/condition-context/op.js");
+const index_js_namespaceObject = require("../../../components/code-editor/index.js");
+const objectRegistry = {
+    type: 'object',
+    ConstantRenderer: (props)=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(index_js_namespaceObject.JsonCodeEditor, {
+            mini: true,
+            value: props.value,
+            onChange: (v)=>props.onChange?.(v),
+            placeholder: editor_namespaceObject.I18n.t('Please Input Object'),
+            readonly: props.readonly
+        }),
+    conditionRule: {
+        [op_js_namespaceObject.ConditionPresetOp.IS_EMPTY]: null,
+        [op_js_namespaceObject.ConditionPresetOp.IS_NOT_EMPTY]: null
+    }
+};
+exports.objectRegistry = __webpack_exports__.objectRegistry;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "objectRegistry"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/json-schema-preset/type-definition/string.js

@@ -0,0 +1,83 @@
+"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__, {
+    stringRegistry: ()=>stringRegistry
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+require("react");
+const editor_namespaceObject = require("@flowgram.ai/editor");
+const semi_ui_namespaceObject = require("@douyinfe/semi-ui");
+const op_js_namespaceObject = require("../../../components/condition-context/op.js");
+const stringRegistry = {
+    type: 'string',
+    ConstantRenderer: (props)=>props?.enableMultiLineStr ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(semi_ui_namespaceObject.TextArea, {
+            autosize: true,
+            rows: 1,
+            placeholder: editor_namespaceObject.I18n.t('Please Input String'),
+            disabled: props.readonly,
+            ...props
+        }) : /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(semi_ui_namespaceObject.Input, {
+            size: "small",
+            placeholder: editor_namespaceObject.I18n.t('Please Input String'),
+            disabled: props.readonly,
+            ...props
+        }),
+    conditionRule: {
+        [op_js_namespaceObject.ConditionPresetOp.EQ]: {
+            type: 'string'
+        },
+        [op_js_namespaceObject.ConditionPresetOp.NEQ]: {
+            type: 'string'
+        },
+        [op_js_namespaceObject.ConditionPresetOp.CONTAINS]: {
+            type: 'string'
+        },
+        [op_js_namespaceObject.ConditionPresetOp.NOT_CONTAINS]: {
+            type: 'string'
+        },
+        [op_js_namespaceObject.ConditionPresetOp.IN]: {
+            type: 'array',
+            items: {
+                type: 'string'
+            }
+        },
+        [op_js_namespaceObject.ConditionPresetOp.NIN]: {
+            type: 'array',
+            items: {
+                type: 'string'
+            }
+        },
+        [op_js_namespaceObject.ConditionPresetOp.IS_EMPTY]: null,
+        [op_js_namespaceObject.ConditionPresetOp.IS_NOT_EMPTY]: null
+    }
+};
+exports.stringRegistry = __webpack_exports__.stringRegistry;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "stringRegistry"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/json-schema-preset/types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __webpack_i__ in __webpack_exports__)exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/shared/flow-value/index.js

@@ -0,0 +1,36 @@
+"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__, {
+    FlowValueUtils: ()=>external_utils_js_namespaceObject.FlowValueUtils
+});
+const external_utils_js_namespaceObject = require("./utils.js");
+exports.FlowValueUtils = __webpack_exports__.FlowValueUtils;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "FlowValueUtils"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/shared/flow-value/schema.js

@@ -0,0 +1,82 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__, {
+    expressionSchema: ()=>expressionSchema,
+    constantSchema: ()=>constantSchema,
+    extraSchema: ()=>extraSchema,
+    templateSchema: ()=>templateSchema,
+    refSchema: ()=>refSchema
+});
+const external_zod_namespaceObject = require("zod");
+var external_zod_default = /*#__PURE__*/ __webpack_require__.n(external_zod_namespaceObject);
+const extraSchema = external_zod_default().object({
+    index: external_zod_default().number().optional()
+}).optional();
+const constantSchema = external_zod_default().object({
+    type: external_zod_default().literal('constant'),
+    content: external_zod_default().any().optional(),
+    schema: external_zod_default().any().optional(),
+    extra: extraSchema
+});
+const refSchema = external_zod_default().object({
+    type: external_zod_default().literal('ref'),
+    content: external_zod_default().array(external_zod_default().string()).optional(),
+    extra: extraSchema
+});
+const expressionSchema = external_zod_default().object({
+    type: external_zod_default().literal('expression'),
+    content: external_zod_default().string().optional(),
+    extra: extraSchema
+});
+const templateSchema = external_zod_default().object({
+    type: external_zod_default().literal('template'),
+    content: external_zod_default().string().optional(),
+    extra: extraSchema
+});
+exports.constantSchema = __webpack_exports__.constantSchema;
+exports.expressionSchema = __webpack_exports__.expressionSchema;
+exports.extraSchema = __webpack_exports__.extraSchema;
+exports.refSchema = __webpack_exports__.refSchema;
+exports.templateSchema = __webpack_exports__.templateSchema;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "constantSchema",
+    "expressionSchema",
+    "extraSchema",
+    "refSchema",
+    "templateSchema"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/shared/flow-value/types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __webpack_i__ in __webpack_exports__)exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/shared/flow-value/utils.js

@@ -0,0 +1,156 @@
+"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__, {
+    FlowValueUtils: ()=>utils_FlowValueUtils
+});
+const external_lodash_es_namespaceObject = require("lodash-es");
+const json_schema_namespaceObject = require("@flowgram.ai/json-schema");
+const external_schema_js_namespaceObject = require("./schema.js");
+(function(FlowValueUtils) {
+    function isConstant(value) {
+        return external_schema_js_namespaceObject.constantSchema.safeParse(value).success;
+    }
+    FlowValueUtils.isConstant = isConstant;
+    function isRef(value) {
+        return external_schema_js_namespaceObject.refSchema.safeParse(value).success;
+    }
+    FlowValueUtils.isRef = isRef;
+    function isExpression(value) {
+        return external_schema_js_namespaceObject.expressionSchema.safeParse(value).success;
+    }
+    FlowValueUtils.isExpression = isExpression;
+    function isTemplate(value) {
+        return external_schema_js_namespaceObject.templateSchema.safeParse(value).success;
+    }
+    FlowValueUtils.isTemplate = isTemplate;
+    function isConstantOrRef(value) {
+        return isConstant(value) || isRef(value);
+    }
+    FlowValueUtils.isConstantOrRef = isConstantOrRef;
+    function isFlowValue(value) {
+        return isConstant(value) || isRef(value) || isExpression(value) || isTemplate(value);
+    }
+    FlowValueUtils.isFlowValue = isFlowValue;
+    function* traverse(value, options) {
+        const { includeTypes = [
+            'ref',
+            'template',
+            'expression',
+            'constant'
+        ], path = '', pathArr = [] } = options || {};
+        if ((0, external_lodash_es_namespaceObject.isPlainObject)(value)) {
+            if (isRef(value) && includeTypes.includes('ref')) return void (yield {
+                value,
+                path,
+                pathArr
+            });
+            if (isTemplate(value) && includeTypes.includes('template')) return void (yield {
+                value,
+                path,
+                pathArr
+            });
+            if (isExpression(value) && includeTypes.includes('expression')) return void (yield {
+                value,
+                path,
+                pathArr
+            });
+            if (isConstant(value) && includeTypes.includes('constant')) return void (yield {
+                value,
+                path,
+                pathArr
+            });
+            for (const [_key, _value] of Object.entries(value))yield* traverse(_value, {
+                ...options,
+                path: path ? `${path}.${_key}` : _key,
+                pathArr: [
+                    ...pathArr,
+                    _key
+                ]
+            });
+            return;
+        }
+        if ((0, external_lodash_es_namespaceObject.isArray)(value)) for (const [_idx, _value] of value.entries())yield* traverse(_value, {
+            ...options,
+            path: path ? `${path}[${_idx}]` : `[${_idx}]`,
+            pathArr: [
+                ...pathArr,
+                `[${_idx}]`
+            ]
+        });
+    }
+    FlowValueUtils.traverse = traverse;
+    function getTemplateKeyPaths(value) {
+        const keyPathReg = /\{\{([^\}\{]+)\}\}/g;
+        return (0, external_lodash_es_namespaceObject.uniq)(value.content?.match(keyPathReg) || []).map((_keyPath)=>_keyPath.slice(2, -2).split('.'));
+    }
+    FlowValueUtils.getTemplateKeyPaths = getTemplateKeyPaths;
+    function inferConstantJsonSchema(value) {
+        if (value?.schema) return value.schema;
+        if ('string' == typeof value.content) return {
+            type: 'string'
+        };
+        if ('number' == typeof value.content) return {
+            type: 'number'
+        };
+        if ('boolean' == typeof value.content) return {
+            type: 'boolean'
+        };
+        if ((0, external_lodash_es_namespaceObject.isObject)(value.content)) return {
+            type: 'object'
+        };
+    }
+    FlowValueUtils.inferConstantJsonSchema = inferConstantJsonSchema;
+    function inferJsonSchema(values, scope) {
+        if ((0, external_lodash_es_namespaceObject.isPlainObject)(values)) {
+            if (isConstant(values)) return inferConstantJsonSchema(values);
+            if (isRef(values)) {
+                const variable = scope.available.getByKeyPath(values?.content);
+                const schema = variable?.type ? json_schema_namespaceObject.JsonSchemaUtils.astToSchema(variable?.type) : void 0;
+                return schema;
+            }
+            if (isTemplate(values)) return {
+                type: 'string'
+            };
+            return {
+                type: 'object',
+                properties: Object.keys(values).reduce((acc, key)=>{
+                    const schema = inferJsonSchema(values[key], scope);
+                    if (schema) acc[key] = schema;
+                    return acc;
+                }, {})
+            };
+        }
+    }
+    FlowValueUtils.inferJsonSchema = inferJsonSchema;
+})(utils_FlowValueUtils || (utils_FlowValueUtils = {}));
+var utils_FlowValueUtils;
+exports.FlowValueUtils = __webpack_exports__.FlowValueUtils;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "FlowValueUtils"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/shared/format-legacy-refs/index.js

@@ -0,0 +1,99 @@
+"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__, {
+    formatLegacyRefOnInit: ()=>formatLegacyRefOnInit,
+    isNewFlowRefValueSchema: ()=>isNewFlowRefValueSchema,
+    formatNewRefToLegacyRef: ()=>formatNewRefToLegacyRef,
+    isLegacyFlowRefValueSchema: ()=>isLegacyFlowRefValueSchema,
+    formatLegacyRefToNewRef: ()=>formatLegacyRefToNewRef,
+    formatLegacyRefOnSubmit: ()=>formatLegacyRefOnSubmit
+});
+const external_lodash_es_namespaceObject = require("lodash-es");
+function formatLegacyRefOnSubmit(value) {
+    if ((0, external_lodash_es_namespaceObject.isObject)(value)) {
+        if (isLegacyFlowRefValueSchema(value)) return formatLegacyRefToNewRef(value);
+        return Object.fromEntries(Object.entries(value).map(([key, value])=>[
+                key,
+                formatLegacyRefOnSubmit(value)
+            ]));
+    }
+    if (Array.isArray(value)) return value.map(formatLegacyRefOnSubmit);
+    return value;
+}
+function formatLegacyRefOnInit(value) {
+    if ((0, external_lodash_es_namespaceObject.isObject)(value)) {
+        if (isNewFlowRefValueSchema(value)) return formatNewRefToLegacyRef(value);
+        return Object.fromEntries(Object.entries(value).map(([key, value])=>[
+                key,
+                formatLegacyRefOnInit(value)
+            ]));
+    }
+    if (Array.isArray(value)) return value.map(formatLegacyRefOnInit);
+    return value;
+}
+function isLegacyFlowRefValueSchema(value) {
+    return (0, external_lodash_es_namespaceObject.isObject)(value) && 2 === Object.keys(value).length && 'ref' === value.type && 'string' == typeof value.content;
+}
+function isNewFlowRefValueSchema(value) {
+    return (0, external_lodash_es_namespaceObject.isObject)(value) && 2 === Object.keys(value).length && 'ref' === value.type && Array.isArray(value.content);
+}
+function formatLegacyRefToNewRef(value) {
+    const keyPath = value.content.split('.');
+    if ('outputs' === keyPath[1]) return {
+        type: 'ref',
+        content: [
+            `${keyPath[0]}.${keyPath[1]}`,
+            ...keyPath.length > 2 ? keyPath.slice(2) : []
+        ]
+    };
+    return {
+        type: 'ref',
+        content: keyPath
+    };
+}
+function formatNewRefToLegacyRef(value) {
+    return {
+        type: 'ref',
+        content: value.content.join('.')
+    };
+}
+exports.formatLegacyRefOnInit = __webpack_exports__.formatLegacyRefOnInit;
+exports.formatLegacyRefOnSubmit = __webpack_exports__.formatLegacyRefOnSubmit;
+exports.formatLegacyRefToNewRef = __webpack_exports__.formatLegacyRefToNewRef;
+exports.formatNewRefToLegacyRef = __webpack_exports__.formatNewRefToLegacyRef;
+exports.isLegacyFlowRefValueSchema = __webpack_exports__.isLegacyFlowRefValueSchema;
+exports.isNewFlowRefValueSchema = __webpack_exports__.isNewFlowRefValueSchema;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "formatLegacyRefOnInit",
+    "formatLegacyRefOnSubmit",
+    "formatLegacyRefToNewRef",
+    "formatNewRefToLegacyRef",
+    "isLegacyFlowRefValueSchema",
+    "isNewFlowRefValueSchema"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});