@webiny/app-admin 6.3.0 → 6.4.0-beta.1

package/features/formModel/LayoutBuilderFactory.js

@@ -1,386 +1,316 @@
 import { isObjectField } from "./ObjectField.js";
-export class TabBuilder {
-  _label = "";
-  constructor(existing) {
-    this._existing = existing;
-  }
-  label(text) {
-    if (this._existing) {
-      this._existing.label = text;
-    } else {
-      this._label = text;
-    }
-    return this;
-  }
-  description(text) {
-    if (this._existing) {
-      this._existing.description = text;
-    } else {
-      this._description = text;
-    }
-    return this;
-  }
-  icon(icon) {
-    if (this._existing) {
-      this._existing.icon = icon;
-    } else {
-      this._icon = icon;
-    }
-    return this;
-  }
-  layout(factory) {
-    if (this._existing) {
-      this._existing.layout.push(...LayoutBuilderFactory.buildNodes(factory(LayoutBuilderFactory.create())));
-    } else {
-      this._layoutFactory = factory;
-    }
-    return this;
-  }
-  rules(r) {
-    if (this._existing) {
-      this._existing.rules = r;
-    } else {
-      this._rules = r;
-    }
-    return this;
-  }
-  _build(id) {
-    if (this._existing) {
-      return this._existing;
-    }
-    return {
-      id,
-      label: this._label,
-      description: this._description,
-      icon: this._icon,
-      layout: this._layoutFactory ? LayoutBuilderFactory.buildNodes(this._layoutFactory(LayoutBuilderFactory.create())) : [],
-      rules: this._rules
-    };
-  }
-}
-export class TabsBuilder {
-  _pendingTabs = [];
-  _lastAddedIdx = -1;
-  constructor(id) {
-    this._id = id;
-  }
-  renderer(name) {
-    this._renderer = name;
-    return this;
-  }
-  tab(tabId, configure) {
-    const tb = new TabBuilder();
-    configure(tb);
-    this._pendingTabs.push({
-      tabId,
-      tabBuilder: tb
-    });
-    this._lastAddedIdx = this._pendingTabs.length - 1;
-    return this;
-  }
-  before(_target) {
-    return this;
-  }
-  after(_target) {
-    return this;
-  }
-  rules(r) {
-    this._rules = r;
-    return this;
-  }
-  build() {
-    return {
-      type: "tabs",
-      id: this._id,
-      renderer: this._renderer,
-      tabs: this._pendingTabs.map(p => p.tabBuilder._build(p.tabId)),
-      rules: this._rules
-    };
-  }
-}
-export class TabsAccessBuilder {
-  _lastAddedIdx = -1;
-  constructor(_node) {
-    this._node = _node;
-  }
-  renderer(name) {
-    this._node.renderer = name;
-    return this;
-  }
-  tab(tabId, configure) {
-    const existing = this._node.tabs.find(t => t.id === tabId);
-    if (existing) {
-      configure(new TabBuilder(existing));
-    } else {
-      const tb = new TabBuilder();
-      configure(tb);
-      this._node.tabs.push(tb._build(tabId));
-      this._lastAddedIdx = this._node.tabs.length - 1;
-    }
-    return this;
-  }
-  before(target) {
-    if (this._lastAddedIdx >= 0) {
-      const tab = this._node.tabs.splice(this._lastAddedIdx, 1)[0];
-      const targetIdx = this._node.tabs.findIndex(t => t.id === target);
-      if (targetIdx !== -1) {
-        this._node.tabs.splice(targetIdx, 0, tab);
-      } else {
-        this._node.tabs.push(tab);
-      }
-    }
-    return this;
-  }
-  after(target) {
-    if (this._lastAddedIdx >= 0) {
-      const tab = this._node.tabs.splice(this._lastAddedIdx, 1)[0];
-      const targetIdx = this._node.tabs.findIndex(t => t.id === target);
-      if (targetIdx !== -1) {
-        this._node.tabs.splice(targetIdx + 1, 0, tab);
-      } else {
-        this._node.tabs.push(tab);
-      }
-    }
-    return this;
-  }
-  rules(r) {
-    this._node.rules = r;
-    return this;
-  }
-  build() {
-    return this._node;
-  }
-}
-export class LayoutBuilderFactory {
-  static create() {
-    return {
-      row(...fieldIds) {
-        let position;
-        const builder = {
-          before(target) {
-            position = {
-              type: "before",
-              target
-            };
-            return builder;
-          },
-          after(target) {
-            position = {
-              type: "after",
-              target
-            };
-            return builder;
-          },
-          build() {
-            return {
-              type: "row",
-              fieldIds,
-              position
-            };
-          }
-        };
-        return builder;
-      },
-      separator() {
+class TabBuilder {
+    constructor(existing){
+        this._label = "";
+        this._existing = existing;
+    }
+    label(text) {
+        if (this._existing) this._existing.label = text;
+        else this._label = text;
+        return this;
+    }
+    description(text) {
+        if (this._existing) this._existing.description = text;
+        else this._description = text;
+        return this;
+    }
+    icon(icon) {
+        if (this._existing) this._existing.icon = icon;
+        else this._icon = icon;
+        return this;
+    }
+    layout(factory) {
+        if (this._existing) this._existing.layout.push(...LayoutBuilderFactory.buildNodes(factory(LayoutBuilderFactory.create())));
+        else this._layoutFactory = factory;
+        return this;
+    }
+    rules(r) {
+        if (this._existing) this._existing.rules = r;
+        else this._rules = r;
+        return this;
+    }
+    _build(id) {
+        if (this._existing) return this._existing;
         return {
-          build() {
-            return {
-              type: "separator"
-            };
-          }
+            id,
+            label: this._label,
+            description: this._description,
+            icon: this._icon,
+            layout: this._layoutFactory ? LayoutBuilderFactory.buildNodes(this._layoutFactory(LayoutBuilderFactory.create())) : [],
+            rules: this._rules
         };
-      },
-      tabs(id) {
-        return new TabsBuilder(id);
-      },
-      element(renderer, props) {
+    }
+}
+class TabsBuilder {
+    constructor(id){
+        this._pendingTabs = [];
+        this._lastAddedIdx = -1;
+        this._id = id;
+    }
+    renderer(name) {
+        this._renderer = name;
+        return this;
+    }
+    tab(tabId, configure) {
+        const tb = new TabBuilder();
+        configure(tb);
+        this._pendingTabs.push({
+            tabId,
+            tabBuilder: tb
+        });
+        this._lastAddedIdx = this._pendingTabs.length - 1;
+        return this;
+    }
+    before(_target) {
+        return this;
+    }
+    after(_target) {
+        return this;
+    }
+    rules(r) {
+        this._rules = r;
+        return this;
+    }
+    build() {
         return {
-          build() {
-            return {
-              type: "element",
-              renderer,
-              props
-            };
-          }
+            type: "tabs",
+            id: this._id,
+            renderer: this._renderer,
+            tabs: this._pendingTabs.map((p)=>p.tabBuilder._build(p.tabId)),
+            rules: this._rules
         };
-      },
-      object(fieldName, inner) {
+    }
+}
+class TabsAccessBuilder {
+    constructor(_node){
+        this._node = _node;
+        this._lastAddedIdx = -1;
+    }
+    renderer(name) {
+        this._node.renderer = name;
+        return this;
+    }
+    tab(tabId, configure) {
+        const existing = this._node.tabs.find((t)=>t.id === tabId);
+        if (existing) configure(new TabBuilder(existing));
+        else {
+            const tb = new TabBuilder();
+            configure(tb);
+            this._node.tabs.push(tb._build(tabId));
+            this._lastAddedIdx = this._node.tabs.length - 1;
+        }
+        return this;
+    }
+    before(target) {
+        if (this._lastAddedIdx >= 0) {
+            const tab = this._node.tabs.splice(this._lastAddedIdx, 1)[0];
+            const targetIdx = this._node.tabs.findIndex((t)=>t.id === target);
+            if (-1 !== targetIdx) this._node.tabs.splice(targetIdx, 0, tab);
+            else this._node.tabs.push(tab);
+        }
+        return this;
+    }
+    after(target) {
+        if (this._lastAddedIdx >= 0) {
+            const tab = this._node.tabs.splice(this._lastAddedIdx, 1)[0];
+            const targetIdx = this._node.tabs.findIndex((t)=>t.id === target);
+            if (-1 !== targetIdx) this._node.tabs.splice(targetIdx + 1, 0, tab);
+            else this._node.tabs.push(tab);
+        }
+        return this;
+    }
+    rules(r) {
+        this._node.rules = r;
+        return this;
+    }
+    build() {
+        return this._node;
+    }
+}
+class LayoutBuilderFactory {
+    static create() {
         return {
-          build() {
-            return {
-              type: "object",
-              fieldName,
-              inner: LayoutBuilderFactory.resolveObjectInner(inner)
-            };
-          }
+            row (...fieldIds) {
+                let position;
+                const builder = {
+                    before (target) {
+                        position = {
+                            type: "before",
+                            target
+                        };
+                        return builder;
+                    },
+                    after (target) {
+                        position = {
+                            type: "after",
+                            target
+                        };
+                        return builder;
+                    },
+                    build () {
+                        return {
+                            type: "row",
+                            fieldIds,
+                            position
+                        };
+                    }
+                };
+                return builder;
+            },
+            separator () {
+                return {
+                    build () {
+                        return {
+                            type: "separator"
+                        };
+                    }
+                };
+            },
+            tabs (id) {
+                return new TabsBuilder(id);
+            },
+            element (renderer, props) {
+                return {
+                    build () {
+                        return {
+                            type: "element",
+                            renderer,
+                            props
+                        };
+                    }
+                };
+            },
+            object (fieldName, inner) {
+                return {
+                    build () {
+                        return {
+                            type: "object",
+                            fieldName,
+                            inner: LayoutBuilderFactory.resolveObjectInner(inner)
+                        };
+                    }
+                };
+            }
         };
-      }
-    };
-  }
-  static buildNodes(builders) {
-    return builders.map(b => b.build());
-  }
-  static resolvePositionedRows(nodes) {
-    const result = [];
-    const deferred = [];
-    for (const node of nodes) {
-      if (node.type === "row" && node.position) {
-        deferred.push({
-          node,
-          position: node.position
+    }
+    static buildNodes(builders) {
+        return builders.map((b)=>b.build());
+    }
+    static resolvePositionedRows(nodes) {
+        const result = [];
+        const deferred = [];
+        for (const node of nodes)if ("row" === node.type && node.position) deferred.push({
+            node,
+            position: node.position
         });
-      } else {
-        result.push(node);
-      }
-    }
-    for (const {
-      node,
-      position
-    } of deferred) {
-      const targetIndex = result.findIndex(n => n.type === "row" && n.fieldIds.includes(position.target));
-      if (targetIndex === -1) {
-        result.push(node);
-        continue;
-      }
-      const insertAt = position.type === "after" ? targetIndex + 1 : targetIndex;
-      result.splice(insertAt, 0, node);
-    }
-    return result;
-  }
-  static resolveObjectInner(inner) {
-    const api = LayoutBuilderFactory.create();
-    if (typeof inner === "function") {
-      return LayoutBuilderFactory.resolvePositionedRows(LayoutBuilderFactory.buildNodes(inner(api)));
-    }
-    const resolved = {};
-    for (const [tplId, factory] of Object.entries(inner)) {
-      resolved[tplId] = LayoutBuilderFactory.resolvePositionedRows(LayoutBuilderFactory.buildNodes(factory(api)));
-    }
-    return resolved;
-  }
-  static createNodeHandle(node) {
-    const handle = {
-      node,
-      before(target) {
-        handle.position = {
-          type: "before",
-          target
+        else result.push(node);
+        for (const { node, position } of deferred){
+            const targetIndex = result.findIndex((n)=>"row" === n.type && n.fieldIds.includes(position.target));
+            if (-1 === targetIndex) {
+                result.push(node);
+                continue;
+            }
+            const insertAt = "after" === position.type ? targetIndex + 1 : targetIndex;
+            result.splice(insertAt, 0, node);
+        }
+        return result;
+    }
+    static resolveObjectInner(inner) {
+        const api = LayoutBuilderFactory.create();
+        if ("function" == typeof inner) return LayoutBuilderFactory.resolvePositionedRows(LayoutBuilderFactory.buildNodes(inner(api)));
+        const resolved = {};
+        for (const [tplId, factory] of Object.entries(inner))resolved[tplId] = LayoutBuilderFactory.resolvePositionedRows(LayoutBuilderFactory.buildNodes(factory(api)));
+        return resolved;
+    }
+    static createNodeHandle(node) {
+        const handle = {
+            node,
+            before (target) {
+                handle.position = {
+                    type: "before",
+                    target
+                };
+                return handle;
+            },
+            after (target) {
+                handle.position = {
+                    type: "after",
+                    target
+                };
+                return handle;
+            },
+            replace (target) {
+                handle.position = {
+                    type: "replace",
+                    target
+                };
+                return handle;
+            }
         };
         return handle;
-      },
-      after(target) {
-        handle.position = {
-          type: "after",
-          target
+    }
+    static matchesNodeId(node, nodeId) {
+        if ("id" in node && node.id === nodeId) return true;
+        if ("object" === node.type && node.fieldName === nodeId) return true;
+        return false;
+    }
+    static findNodeById(layout, nodeId) {
+        for (const node of layout){
+            if (LayoutBuilderFactory.matchesNodeId(node, nodeId)) return node;
+            if ("tabs" === node.type) for (const tab of node.tabs){
+                const found = LayoutBuilderFactory.findNodeById(tab.layout, nodeId);
+                if (found) return found;
+            }
+        }
+    }
+    static resolveTabDefinition(input) {
+        const api = LayoutBuilderFactory.create();
+        return {
+            id: input.id,
+            label: input.label,
+            description: input.description,
+            icon: input.icon,
+            rules: input.rules,
+            layout: LayoutBuilderFactory.buildNodes(input.layout(api))
         };
-        return handle;
-      },
-      replace(target) {
-        handle.position = {
-          type: "replace",
-          target
+    }
+    static tabsNodeKey(node) {
+        return `__tabs_${node.tabs.map((t)=>t.id).join("_")}`;
+    }
+    static accessNode(layout, nodeId) {
+        return {
+            as: (type)=>{
+                const node = LayoutBuilderFactory.findNodeById(layout, nodeId);
+                if (!node) throw new Error(`Layout node "${nodeId}" not found.`);
+                if (node.type !== type) throw new Error(`Layout node "${nodeId}" is type "${node.type}", not "${type}".`);
+                if ("tabs" === type) return new TabsAccessBuilder(node);
+                return node;
+            }
         };
-        return handle;
-      }
-    };
-    return handle;
-  }
-  static matchesNodeId(node, nodeId) {
-    if ("id" in node && node.id === nodeId) {
-      return true;
-    }
-    if (node.type === "object" && node.fieldName === nodeId) {
-      return true;
-    }
-    return false;
-  }
-  static findNodeById(layout, nodeId) {
-    for (const node of layout) {
-      if (LayoutBuilderFactory.matchesNodeId(node, nodeId)) {
-        return node;
-      }
-      if (node.type === "tabs") {
-        for (const tab of node.tabs) {
-          const found = LayoutBuilderFactory.findNodeById(tab.layout, nodeId);
-          if (found) {
-            return found;
-          }
-        }
-      }
-    }
-    return undefined;
-  }
-  static resolveTabDefinition(input) {
-    const api = LayoutBuilderFactory.create();
-    return {
-      id: input.id,
-      label: input.label,
-      description: input.description,
-      icon: input.icon,
-      rules: input.rules,
-      layout: LayoutBuilderFactory.buildNodes(input.layout(api))
-    };
-  }
-  static tabsNodeKey(node) {
-    return `__tabs_${node.tabs.map(t => t.id).join("_")}`;
-  }
-  static accessNode(layout, nodeId) {
-    return {
-      as: type => {
-        const node = LayoutBuilderFactory.findNodeById(layout, nodeId);
-        if (!node) {
-          throw new Error(`Layout node "${nodeId}" not found.`);
-        }
-        if (node.type !== type) {
-          throw new Error(`Layout node "${nodeId}" is type "${node.type}", not "${type}".`);
-        }
-        if (type === "tabs") {
-          return new TabsAccessBuilder(node);
-        }
-        return node;
-      }
-    };
-  }
-  static collectBuilders(fields, builders, predicate, result) {
-    const entries = builders instanceof Map ? builders.entries() : Object.entries(builders);
-    for (const [name, builder] of entries) {
-      if (predicate(builder)) {
-        result.push(builder);
-      }
-      const field = fields instanceof Map ? fields.get(name) : undefined;
-      if (field && isObjectField(field)) {
-        LayoutBuilderFactory.collectBuilders(field.children, field.config.childBuilders, predicate, result);
-        const templates = field.config.templates;
-        if (templates) {
-          for (const tpl of templates) {
-            LayoutBuilderFactory.collectBuildersFlat(tpl.childBuilders, predicate, result);
-          }
-        }
-      }
-    }
-  }
-  static collectFieldIds(layout) {
-    const ids = [];
-    for (const node of layout) {
-      if (node.type === "row") {
-        ids.push(...node.fieldIds);
-      } else if (node.type === "tabs") {
-        for (const tab of node.tabs) {
-          ids.push(...LayoutBuilderFactory.collectFieldIds(tab.layout));
+    }
+    static collectBuilders(fields, builders, predicate, result) {
+        const entries = builders instanceof Map ? builders.entries() : Object.entries(builders);
+        for (const [name, builder] of entries){
+            if (predicate(builder)) result.push(builder);
+            const field = fields instanceof Map ? fields.get(name) : void 0;
+            if (field && isObjectField(field)) {
+                LayoutBuilderFactory.collectBuilders(field.children, field.config.childBuilders, predicate, result);
+                const templates = field.config.templates;
+                if (templates) for (const tpl of templates)LayoutBuilderFactory.collectBuildersFlat(tpl.childBuilders, predicate, result);
+            }
         }
-      } else if (node.type === "object") {
-        ids.push(node.fieldName);
-      }
-    }
-    return ids;
-  }
-  static collectBuildersFlat(builders, predicate, result) {
-    for (const builder of Object.values(builders)) {
-      if (predicate(builder)) {
-        result.push(builder);
-      }
-    }
-  }
+    }
+    static collectFieldIds(layout) {
+        const ids = [];
+        for (const node of layout)if ("row" === node.type) ids.push(...node.fieldIds);
+        else if ("tabs" === node.type) for (const tab of node.tabs)ids.push(...LayoutBuilderFactory.collectFieldIds(tab.layout));
+        else if ("object" === node.type) ids.push(node.fieldName);
+        return ids;
+    }
+    static collectBuildersFlat(builders, predicate, result) {
+        for (const builder of Object.values(builders))if (predicate(builder)) result.push(builder);
+    }
 }
+export { LayoutBuilderFactory, TabBuilder, TabsAccessBuilder, TabsBuilder };
 
 //# sourceMappingURL=LayoutBuilderFactory.js.map