@sulesky/next-formily-transformer 1.0.3

package/LICENSE.md

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-present, Alibaba Group Holding Limited. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# @designable/formily

package/esm/index.d.ts

@@ -0,0 +1,12 @@
+import { ISchema } from '@formily/json-schema';
+import { ITreeNode } from '@sulesky/next-core';
+export interface ITransformerOptions {
+    designableFieldName?: string;
+    designableFormName?: string;
+}
+export interface IFormilySchema {
+    schema?: ISchema;
+    form?: Record<string, any>;
+}
+export declare const transformToSchema: (node: ITreeNode, options?: ITransformerOptions) => IFormilySchema;
+export declare const transformToTreeNode: (formily?: IFormilySchema, options?: ITransformerOptions) => ITreeNode;

package/esm/index.js

@@ -0,0 +1,117 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { Schema } from '@formily/json-schema';
+import { clone, uid } from '@sulesky/next-shared';
+var createOptions = function (options) {
+    return __assign({ designableFieldName: 'Field', designableFormName: 'Form' }, options);
+};
+var findNode = function (node, finder) {
+    if (!node)
+        return;
+    if (finder(node))
+        return node;
+    if (!node.children)
+        return;
+    for (var i = 0; i < node.children.length; i++) {
+        if (findNode(node.children[i]))
+            return node.children[i];
+    }
+    return;
+};
+export var transformToSchema = function (node, options) {
+    var realOptions = createOptions(options);
+    var root = findNode(node, function (child) {
+        return child.componentName === realOptions.designableFormName;
+    });
+    var schema = {
+        type: 'object',
+        properties: {},
+    };
+    if (!root)
+        return { schema: schema };
+    var createSchema = function (node, schema) {
+        if (schema === void 0) { schema = {}; }
+        if (node !== root) {
+            Object.assign(schema, clone(node.props));
+        }
+        schema['x-designable-id'] = node.id;
+        if (schema.type === 'array') {
+            if (node.children[0]) {
+                if (node.children[0].componentName === realOptions.designableFieldName) {
+                    schema.items = createSchema(node.children[0]);
+                    schema['x-index'] = 0;
+                }
+            }
+            node.children.slice(1).forEach(function (child, index) {
+                if (child.componentName !== realOptions.designableFieldName)
+                    return;
+                var key = child.props.name || child.id;
+                schema.properties = schema.properties || {};
+                schema.properties[key] = createSchema(child);
+                schema.properties[key]['x-index'] = index;
+            });
+        }
+        else {
+            node.children.forEach(function (child, index) {
+                if (child.componentName !== realOptions.designableFieldName)
+                    return;
+                var key = child.props.name || child.id;
+                schema.properties = schema.properties || {};
+                schema.properties[key] = createSchema(child);
+                schema.properties[key]['x-index'] = index;
+            });
+        }
+        return schema;
+    };
+    return { form: clone(root.props), schema: createSchema(root, schema) };
+};
+export var transformToTreeNode = function (formily, options) {
+    if (formily === void 0) { formily = {}; }
+    var realOptions = createOptions(options);
+    var root = {
+        componentName: realOptions.designableFormName,
+        props: formily.form,
+        children: [],
+    };
+    var schema = new Schema(formily.schema);
+    var cleanProps = function (props) {
+        if (props['name'] === props['x-designable-id']) {
+            delete props.name;
+        }
+        delete props['version'];
+        delete props['_isJSONSchemaObject'];
+        return props;
+    };
+    var appendTreeNode = function (parent, schema) {
+        if (!schema)
+            return;
+        var current = {
+            id: schema['x-designable-id'] || uid(),
+            componentName: realOptions.designableFieldName,
+            props: cleanProps(schema.toJSON(false)),
+            children: [],
+        };
+        parent.children.push(current);
+        if (schema.items && !Array.isArray(schema.items)) {
+            appendTreeNode(current, schema.items);
+        }
+        schema.mapProperties(function (schema) {
+            schema['x-designable-id'] = schema['x-designable-id'] || uid();
+            appendTreeNode(current, schema);
+        });
+    };
+    schema.mapProperties(function (schema) {
+        schema['x-designable-id'] = schema['x-designable-id'] || uid();
+        appendTreeNode(root, schema);
+    });
+    return root;
+};

package/lib/index.d.ts

@@ -0,0 +1,12 @@
+import { ISchema } from '@formily/json-schema';
+import { ITreeNode } from '@sulesky/next-core';
+export interface ITransformerOptions {
+    designableFieldName?: string;
+    designableFormName?: string;
+}
+export interface IFormilySchema {
+    schema?: ISchema;
+    form?: Record<string, any>;
+}
+export declare const transformToSchema: (node: ITreeNode, options?: ITransformerOptions) => IFormilySchema;
+export declare const transformToTreeNode: (formily?: IFormilySchema, options?: ITransformerOptions) => ITreeNode;

package/lib/index.js

@@ -0,0 +1,122 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformToTreeNode = exports.transformToSchema = void 0;
+var json_schema_1 = require("@formily/json-schema");
+var next_shared_1 = require("@sulesky/next-shared");
+var createOptions = function (options) {
+    return __assign({ designableFieldName: 'Field', designableFormName: 'Form' }, options);
+};
+var findNode = function (node, finder) {
+    if (!node)
+        return;
+    if (finder(node))
+        return node;
+    if (!node.children)
+        return;
+    for (var i = 0; i < node.children.length; i++) {
+        if (findNode(node.children[i]))
+            return node.children[i];
+    }
+    return;
+};
+var transformToSchema = function (node, options) {
+    var realOptions = createOptions(options);
+    var root = findNode(node, function (child) {
+        return child.componentName === realOptions.designableFormName;
+    });
+    var schema = {
+        type: 'object',
+        properties: {},
+    };
+    if (!root)
+        return { schema: schema };
+    var createSchema = function (node, schema) {
+        if (schema === void 0) { schema = {}; }
+        if (node !== root) {
+            Object.assign(schema, (0, next_shared_1.clone)(node.props));
+        }
+        schema['x-designable-id'] = node.id;
+        if (schema.type === 'array') {
+            if (node.children[0]) {
+                if (node.children[0].componentName === realOptions.designableFieldName) {
+                    schema.items = createSchema(node.children[0]);
+                    schema['x-index'] = 0;
+                }
+            }
+            node.children.slice(1).forEach(function (child, index) {
+                if (child.componentName !== realOptions.designableFieldName)
+                    return;
+                var key = child.props.name || child.id;
+                schema.properties = schema.properties || {};
+                schema.properties[key] = createSchema(child);
+                schema.properties[key]['x-index'] = index;
+            });
+        }
+        else {
+            node.children.forEach(function (child, index) {
+                if (child.componentName !== realOptions.designableFieldName)
+                    return;
+                var key = child.props.name || child.id;
+                schema.properties = schema.properties || {};
+                schema.properties[key] = createSchema(child);
+                schema.properties[key]['x-index'] = index;
+            });
+        }
+        return schema;
+    };
+    return { form: (0, next_shared_1.clone)(root.props), schema: createSchema(root, schema) };
+};
+exports.transformToSchema = transformToSchema;
+var transformToTreeNode = function (formily, options) {
+    if (formily === void 0) { formily = {}; }
+    var realOptions = createOptions(options);
+    var root = {
+        componentName: realOptions.designableFormName,
+        props: formily.form,
+        children: [],
+    };
+    var schema = new json_schema_1.Schema(formily.schema);
+    var cleanProps = function (props) {
+        if (props['name'] === props['x-designable-id']) {
+            delete props.name;
+        }
+        delete props['version'];
+        delete props['_isJSONSchemaObject'];
+        return props;
+    };
+    var appendTreeNode = function (parent, schema) {
+        if (!schema)
+            return;
+        var current = {
+            id: schema['x-designable-id'] || (0, next_shared_1.uid)(),
+            componentName: realOptions.designableFieldName,
+            props: cleanProps(schema.toJSON(false)),
+            children: [],
+        };
+        parent.children.push(current);
+        if (schema.items && !Array.isArray(schema.items)) {
+            appendTreeNode(current, schema.items);
+        }
+        schema.mapProperties(function (schema) {
+            schema['x-designable-id'] = schema['x-designable-id'] || (0, next_shared_1.uid)();
+            appendTreeNode(current, schema);
+        });
+    };
+    schema.mapProperties(function (schema) {
+        schema['x-designable-id'] = schema['x-designable-id'] || (0, next_shared_1.uid)();
+        appendTreeNode(root, schema);
+    });
+    return root;
+};
+exports.transformToTreeNode = transformToTreeNode;

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@sulesky/next-formily-transformer",
+  "version": "1.0.3",
+  "license": "MIT",
+  "main": "lib",
+  "engines": {
+    "npm": ">=3.0.0"
+  },
+  "module": "esm",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kapelan/designable.git"
+  },
+  "types": "esm/index.d.ts",
+  "bugs": {
+    "url": "https://github.com/kapelan/designable/issues"
+  },
+  "homepage": "https://github.com/kapelan/designable#readme",
+  "scripts": {
+    "build": "rimraf -rf lib esm dist && npm run build:cjs && npm run build:esm",
+    "build:cjs": "tsc --project tsconfig.build.json",
+    "build:esm": "tsc --project tsconfig.build.json --module es2015 --outDir esm"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@formily/core": "^2.3.0",
+    "@formily/json-schema": "^2.3.0"
+  },
+  "peerDependencies": {
+    "@formily/core": "^2.3.0",
+    "@formily/json-schema": "^2.3.0"
+  },
+  "dependencies": {
+    "@sulesky/next-core": "1.0.3",
+    "@sulesky/next-shared": "1.0.3"
+  },
+  "gitHead": "c352e7550efc1420491dfc18b9418ec4fcfcc4ae"
+}

package/rollup.config.mjs

@@ -0,0 +1,3 @@
+import baseConfig from '../../scripts/rollup.base.mjs'
+
+export default baseConfig('designable.formily', 'Designable.Formily')

package/src/index.ts

@@ -0,0 +1,122 @@
+import { ISchema, Schema } from '@formily/json-schema'
+import { ITreeNode } from '@sulesky/next-core'
+import { clone, uid } from '@sulesky/next-shared'
+
+export interface ITransformerOptions {
+  designableFieldName?: string
+  designableFormName?: string
+}
+
+export interface IFormilySchema {
+  schema?: ISchema
+  form?: Record<string, any>
+}
+
+const createOptions = (options: ITransformerOptions): ITransformerOptions => {
+  return {
+    designableFieldName: 'Field',
+    designableFormName: 'Form',
+    ...options,
+  }
+}
+
+const findNode = (node: ITreeNode, finder?: (node: ITreeNode) => boolean) => {
+  if (!node) return
+  if (finder(node)) return node
+  if (!node.children) return
+  for (let i = 0; i < node.children.length; i++) {
+    if (findNode(node.children[i])) return node.children[i]
+  }
+  return
+}
+
+export const transformToSchema = (
+  node: ITreeNode,
+  options?: ITransformerOptions
+): IFormilySchema => {
+  const realOptions = createOptions(options)
+  const root = findNode(node, (child) => {
+    return child.componentName === realOptions.designableFormName
+  })
+  const schema = {
+    type: 'object',
+    properties: {},
+  }
+  if (!root) return { schema }
+  const createSchema = (node: ITreeNode, schema: ISchema = {}) => {
+    if (node !== root) {
+      Object.assign(schema, clone(node.props))
+    }
+    schema['x-designable-id'] = node.id
+    if (schema.type === 'array') {
+      if (node.children[0]) {
+        if (
+          node.children[0].componentName === realOptions.designableFieldName
+        ) {
+          schema.items = createSchema(node.children[0])
+          schema['x-index'] = 0
+        }
+      }
+      node.children.slice(1).forEach((child, index) => {
+        if (child.componentName !== realOptions.designableFieldName) return
+        const key = child.props.name || child.id
+        schema.properties = schema.properties || {}
+        schema.properties[key] = createSchema(child)
+        schema.properties[key]['x-index'] = index
+      })
+    } else {
+      node.children.forEach((child, index) => {
+        if (child.componentName !== realOptions.designableFieldName) return
+        const key = child.props.name || child.id
+        schema.properties = schema.properties || {}
+        schema.properties[key] = createSchema(child)
+        schema.properties[key]['x-index'] = index
+      })
+    }
+    return schema
+  }
+  return { form: clone(root.props), schema: createSchema(root, schema) }
+}
+
+export const transformToTreeNode = (
+  formily: IFormilySchema = {},
+  options?: ITransformerOptions
+) => {
+  const realOptions = createOptions(options)
+  const root: ITreeNode = {
+    componentName: realOptions.designableFormName,
+    props: formily.form,
+    children: [],
+  }
+  const schema = new Schema(formily.schema)
+  const cleanProps = (props: any) => {
+    if (props['name'] === props['x-designable-id']) {
+      delete props.name
+    }
+    delete props['version']
+    delete props['_isJSONSchemaObject']
+    return props
+  }
+  const appendTreeNode = (parent: ITreeNode, schema: Schema) => {
+    if (!schema) return
+    const current = {
+      id: schema['x-designable-id'] || uid(),
+      componentName: realOptions.designableFieldName,
+      props: cleanProps(schema.toJSON(false)),
+      children: [],
+    }
+    parent.children.push(current)
+    if (schema.items && !Array.isArray(schema.items)) {
+      appendTreeNode(current, schema.items)
+    }
+    schema.mapProperties((schema) => {
+      schema['x-designable-id'] = schema['x-designable-id'] || uid()
+      appendTreeNode(current, schema)
+    })
+  }
+  schema.mapProperties((schema) => {
+    schema['x-designable-id'] = schema['x-designable-id'] || uid()
+    appendTreeNode(root, schema)
+  })
+  return root
+}

package/tsconfig.build.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./lib",
+    "paths": {
+      "@sulesky/next-*": ["../../packages/*", "../../formily/*"]
+    },
+    "declaration": true
+  }
+}

package/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "../../tsconfig.json",
+  "include": ["./src/**/*.ts", "./src/**/*.tsx"],
+  "exclude": ["./src/__tests__/*", "./esm/*", "./lib/*"]
+}