@player-tools/dsl 0.5.0--canary.62.1176 → 0.5.0-next.0

package/dist/index.legacy-esm.js

@@ -0,0 +1,910 @@
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/src/components.tsx
+import React4 from "react";
+import mergeRefs from "react-merge-refs";
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/src/auto-id.tsx
+import React from "react";
+import { flattenNodes } from "react-json-reconciler";
+var IDSuffixContext = React.createContext("root");
+var IndexSuffixStopContext = React.createContext(false);
+var useGetIdPrefix = () => {
+  return React.useContext(IDSuffixContext);
+};
+var IDSuffixProvider = (props) => {
+  const currentPrefix = useGetIdPrefix();
+  return /* @__PURE__ */ React.createElement(
+    IDSuffixContext.Provider,
+    {
+      value: [
+        currentPrefix === "root" ? void 0 : currentPrefix,
+        props.suffix
+      ].filter(Boolean).join("-")
+    },
+    props.children
+  );
+};
+var IDProvider = (props) => {
+  if (props.id) {
+    return /* @__PURE__ */ React.createElement(IDSuffixContext.Provider, { value: props.id }, props.children);
+  }
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, props.children);
+};
+var useIndexInSlot = (ref) => {
+  const [index, setIndex] = React.useState(-1);
+  const slotContext = React.useContext(SlotContext);
+  React.useEffect(() => {
+    if (!slotContext?.isArray) {
+      throw new Error("Cannot get index in non-array slot");
+    }
+    if (ref.current && slotContext?.ref.current?.valueNode?.type === "array") {
+      const allChildren = flattenNodes(
+        slotContext.ref.current.valueNode.children
+      );
+      const foundIndex = allChildren.indexOf(ref.current);
+      if (foundIndex !== index) {
+        setIndex(foundIndex);
+      }
+    }
+  }, [index, ref, slotContext?.isArray, slotContext?.ref]);
+  return index;
+};
+var IDSuffixIndexProvider = (props) => {
+  const slotIndex = useIndexInSlot(props.wrapperRef);
+  const stopIndex = React.useContext(IndexSuffixStopContext);
+  if (stopIndex) {
+    return /* @__PURE__ */ React.createElement(React.Fragment, null, props.children);
+  }
+  return /* @__PURE__ */ React.createElement(IDSuffixProvider, { suffix: props.templateIndex ?? String(slotIndex) }, /* @__PURE__ */ React.createElement(IndexSuffixStopContext.Provider, { value: true }, props.children));
+};
+var OptionalIDSuffixProvider = (props) => {
+  const slotContext = React.useContext(SlotContext);
+  if (slotContext?.isArray) {
+    return /* @__PURE__ */ React.createElement(
+      IDSuffixIndexProvider,
+      {
+        wrapperRef: props.wrapperRef,
+        templateIndex: props.templateIndex
+      },
+      props.children
+    );
+  }
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, props.children);
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/src/utils.tsx
+import * as React3 from "react";
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/src/string-templates/index.ts
+import * as React2 from "react";
+import { parseExpression } from "@player-ui/player";
+var OpaqueIdentifier = Symbol("TemplateStringType");
+var TemplateStringComponent = (props) => {
+  return React2.createElement(
+    "value",
+    {
+      value: props.value
+    },
+    null
+  );
+};
+var createTemplateInstance = (options) => {
+  const value = options.strings.reduce((sum, next, i) => {
+    const element2 = options.other[i];
+    if (typeof element2 === "string") {
+      return sum + next + element2;
+    }
+    return sum + next + (element2?.toRefString(options) ?? "");
+  }, "");
+  if (options.nestedContext === "expression") {
+    const parsedExpression = parseExpression(value, { strict: false });
+    if (parsedExpression.error) {
+      throw parsedExpression.error;
+    }
+  }
+  const toString = () => {
+    return options.toRefString({}, value);
+  };
+  const toValue = () => {
+    return value;
+  };
+  const element = React2.createElement(
+    TemplateStringComponent,
+    {
+      value: toString()
+    },
+    null
+  );
+  return {
+    ...element,
+    [OpaqueIdentifier]: true,
+    toString,
+    toValue,
+    toRefString: (refStringOptions) => {
+      return options.toRefString(refStringOptions, value);
+    }
+  };
+};
+var addBindingIndexes = (binding2) => {
+  let currentIndex = 0;
+  return binding2.replace(/_index_/g, () => {
+    const result = `_index${currentIndex > 0 ? currentIndex : ""}_`;
+    currentIndex += 1;
+    return result;
+  });
+};
+var createBindingTemplateInstance = (options) => {
+  const templateInstance = createTemplateInstance({
+    ...options,
+    strings: options.strings.map(
+      (element) => addBindingIndexes(element)
+    ),
+    other: options.other.map(
+      (element) => typeof element === "string" ? addBindingIndexes(element) : element
+    ),
+    toRefString: (context, value) => {
+      return `{{${value}}}`;
+    }
+  });
+  templateInstance.__type = "binding";
+  return templateInstance;
+};
+var createExpressionTemplateInstance = (options) => {
+  const templateInstance = createTemplateInstance({
+    ...options,
+    toRefString: (contextOptions, value) => {
+      if (contextOptions?.nestedContext === "expression") {
+        return value;
+      }
+      const inBinding = contextOptions?.nestedContext === "binding";
+      return `${inBinding ? "`" : "@["}${value}${inBinding ? "`" : "]@"}`;
+    }
+  });
+  templateInstance.__type = "expression";
+  return templateInstance;
+};
+var binding = (strings, ...nested) => {
+  return createBindingTemplateInstance({
+    strings,
+    other: nested,
+    nestedContext: "binding"
+  });
+};
+var expression = (strings, ...nested) => {
+  return createExpressionTemplateInstance({
+    strings,
+    other: nested,
+    nestedContext: "expression"
+  });
+};
+var isTemplateStringInstance = (val) => {
+  return val !== null && typeof val === "object" && val[OpaqueIdentifier] === true;
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/src/utils.tsx
+function toArray(val) {
+  return Array.isArray(val) ? val : [val];
+}
+function toJsonElement(value, indexOrKey, options) {
+  const indexProp = typeof indexOrKey === "number" ? { key: indexOrKey } : null;
+  if (Array.isArray(value)) {
+    return /* @__PURE__ */ React3.createElement("array", { ...indexProp }, value.map((item, idx) => toJsonElement(item, idx, options)));
+  }
+  if (isTemplateStringInstance(value)) {
+    if (typeof indexOrKey === "string" && options?.propertiesToSkip?.includes(indexOrKey)) {
+      return /* @__PURE__ */ React3.createElement("value", { ...indexProp }, value.toValue());
+    }
+    return /* @__PURE__ */ React3.createElement("value", { ...indexProp }, value.toRefString());
+  }
+  if (typeof value === "object" && value !== null) {
+    return /* @__PURE__ */ React3.createElement("obj", { ...indexProp }, Object.keys(value).map((key) => /* @__PURE__ */ React3.createElement("property", { key, name: key }, toJsonElement(value[key], key, options))));
+  }
+  return /* @__PURE__ */ React3.createElement("value", { ...indexProp, value });
+}
+function toJsonProperties(value, options = { propertiesToSkip: ["applicability"] }) {
+  return Object.keys(value).map((key) => {
+    return /* @__PURE__ */ React3.createElement("property", { key, name: key }, toJsonElement(value[key], key, options));
+  });
+}
+function normalizeText(options) {
+  const { node, TextComp } = options;
+  const nodeArr = React3.Children.toArray(node);
+  if (nodeArr.every(
+    (n) => React3.isValidElement(n) && n.type !== TemplateStringComponent
+  )) {
+    return node;
+  }
+  if (TextComp) {
+    return /* @__PURE__ */ React3.createElement(TextComp, null, nodeArr);
+  }
+  throw new Error(
+    `Tried to convert node to Text Asset, but no Component was supplied.`
+  );
+}
+function normalizeToCollection(options) {
+  const { node, CollectionComp } = options;
+  if (React3.Children.count(node) > 1 && React3.Children.toArray(node).every((n) => typeof n !== "string")) {
+    if (!CollectionComp) {
+      throw new Error(
+        `Tried to convert array to a collection asset, but no Component was given.`
+      );
+    }
+    return /* @__PURE__ */ React3.createElement(CollectionComp, null, node);
+  }
+  return normalizeText({ ...options, node });
+}
+function flattenChildren(children) {
+  const childrenArray = React3.Children.toArray(children);
+  return childrenArray.reduce((flatChildren, child) => {
+    if (child.type === React3.Fragment) {
+      return flatChildren.concat(
+        flattenChildren(child.props.children)
+      );
+    }
+    flatChildren.push(child);
+    return flatChildren;
+  }, []);
+}
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/src/components.tsx
+var SlotContext = React4.createContext(void 0);
+var AssetWrapper = React4.forwardRef(function AssetWrapper2(props, ref) {
+  const { children, ...rest } = props;
+  return /* @__PURE__ */ React4.createElement("obj", { ref }, toJsonProperties(rest), /* @__PURE__ */ React4.createElement("property", { name: "asset" }, children));
+});
+var GeneratedIDProperty = (props) => {
+  const currentPrefixId = useGetIdPrefix();
+  return /* @__PURE__ */ React4.createElement("property", { name: "id" }, props.id ?? currentPrefixId);
+};
+var Asset = React4.forwardRef((props, ref) => {
+  const { id, type, applicability, children, ...rest } = props;
+  const slotContext = React4.useContext(SlotContext);
+  const localRef = React4.useRef(null);
+  const Wrapper = slotContext?.wrapInAsset ? AssetWrapper : React4.Fragment;
+  return /* @__PURE__ */ React4.createElement(
+    Wrapper,
+    {
+      ref: slotContext?.wrapInAsset ? mergeRefs([ref, localRef]) : void 0,
+      ...slotContext?.wrapInAsset && slotContext?.additionalProperties ? slotContext?.additionalProperties : {}
+    },
+    /* @__PURE__ */ React4.createElement(OptionalIDSuffixProvider, { wrapperRef: localRef }, /* @__PURE__ */ React4.createElement(SlotContext.Provider, { value: void 0 }, /* @__PURE__ */ React4.createElement(IDProvider, { id }, /* @__PURE__ */ React4.createElement(
+      "obj",
+      {
+        ref: slotContext?.wrapInAsset ? void 0 : mergeRefs([ref, localRef])
+      },
+      /* @__PURE__ */ React4.createElement(GeneratedIDProperty, { id }),
+      /* @__PURE__ */ React4.createElement("property", { name: "type" }, type),
+      applicability !== void 0 && /* @__PURE__ */ React4.createElement("property", { name: "applicability" }, /* @__PURE__ */ React4.createElement(
+        "value",
+        {
+          value: typeof applicability === "boolean" ? applicability : applicability.toValue()
+        }
+      )),
+      toJsonProperties(rest),
+      children
+    ))))
+  );
+});
+Asset.displayName = "Asset";
+Asset.defaultProps = {
+  id: void 0,
+  children: void 0
+};
+var View = React4.forwardRef(
+  (props, ref) => {
+    const { validation, children, ...rest } = props;
+    return /* @__PURE__ */ React4.createElement(Asset, { ref, ...rest }, validation && /* @__PURE__ */ React4.createElement("property", { key: "validation", name: "validation" }, toJsonElement(validation, "validation", {
+      propertiesToSkip: ["ref"]
+    })), children);
+  }
+);
+View.displayName = "View";
+View.defaultProps = {
+  id: void 0,
+  children: void 0
+};
+var Slot = (props) => {
+  const { TextComp, CollectionComp } = props;
+  const children = flattenChildren(props.children);
+  const propRef = React4.useRef(null);
+  return /* @__PURE__ */ React4.createElement("property", { ref: propRef, name: props.name }, /* @__PURE__ */ React4.createElement(IDSuffixProvider, { suffix: props.name }, /* @__PURE__ */ React4.createElement(IndexSuffixStopContext.Provider, { value: false }, /* @__PURE__ */ React4.createElement(
+    SlotContext.Provider,
+    {
+      value: {
+        ref: propRef,
+        propertyName: props.name,
+        wrapInAsset: props.wrapInAsset ?? false,
+        isArray: props.isArray ?? false,
+        additionalProperties: props.additionalProperties,
+        TextComp,
+        CollectionComp
+      }
+    },
+    props.isArray && /* @__PURE__ */ React4.createElement("array", null, React4.Children.map(children, (child, index) => {
+      return (
+        // eslint-disable-next-line react/no-array-index-key
+        /* @__PURE__ */ React4.createElement(React4.Fragment, { key: `${props.name}-${index}` }, normalizeText({ node: child, TextComp }))
+      );
+    })),
+    !props.isArray && normalizeToCollection({
+      node: children,
+      TextComp,
+      CollectionComp
+    })
+  ))));
+};
+function createSlot(options) {
+  return (props) => {
+    const { children, ...other } = props;
+    return /* @__PURE__ */ React4.createElement(Slot, { ...options, additionalProperties: other }, children);
+  };
+}
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/src/switch.tsx
+import React5 from "react";
+import { flattenNodes as flattenNodes2 } from "react-json-reconciler";
+var SwitchContext = React5.createContext({});
+var Switch = (props) => {
+  const slotContext = React5.useContext(SlotContext);
+  const propertyNode = React5.useRef(null);
+  return /* @__PURE__ */ React5.createElement("obj", { ref: propertyNode }, /* @__PURE__ */ React5.createElement(
+    SwitchContext.Provider,
+    {
+      value: {
+        ...props,
+        TextComp: slotContext?.TextComp,
+        CollectionComp: slotContext?.CollectionComp
+      }
+    },
+    /* @__PURE__ */ React5.createElement(OptionalIDSuffixProvider, { wrapperRef: propertyNode }, /* @__PURE__ */ React5.createElement("property", { name: props.isDynamic ? "dynamicSwitch" : "staticSwitch" }, /* @__PURE__ */ React5.createElement(SlotContext.Provider, { value: void 0 }, /* @__PURE__ */ React5.createElement("array", null, props.children))))
+  ), slotContext?.additionalProperties && toJsonProperties(slotContext.additionalProperties));
+};
+var findParentArray = (node) => {
+  if (node.type === "array") {
+    return node;
+  }
+  if (node.parent) {
+    return findParentArray(node.parent);
+  }
+  throw new Error("can't find parent array");
+};
+var findArrayIndex = (node) => {
+  const parentArray = findParentArray(node);
+  const allSearch = flattenNodes2(parentArray.children);
+  return allSearch.indexOf(node);
+};
+var Case = (props) => {
+  const slotContext = React5.useContext(SlotContext);
+  const switchContext = React5.useContext(SwitchContext);
+  const [caseIndex, setCaseIndex] = React5.useState(-1);
+  const caseNode = React5.useRef(null);
+  React5.useLayoutEffect(() => {
+    if (caseNode.current) {
+      const index = findArrayIndex(caseNode.current);
+      if (index !== caseIndex) {
+        setCaseIndex(index);
+      }
+    }
+  }, [caseIndex]);
+  let expValue = true;
+  if (props.exp !== void 0) {
+    expValue = isTemplateStringInstance(props.exp) ? props.exp.toValue() : props.exp;
+  }
+  return /* @__PURE__ */ React5.createElement("obj", { ref: caseNode }, /* @__PURE__ */ React5.createElement("property", { name: "case" }, /* @__PURE__ */ React5.createElement("value", { value: expValue })), /* @__PURE__ */ React5.createElement(
+    IDSuffixProvider,
+    {
+      suffix: `${switchContext.isDynamic ? "dynamicSwitch" : "staticSwitch"}-${caseIndex}`
+    },
+    /* @__PURE__ */ React5.createElement(
+      SlotContext.Provider,
+      {
+        value: slotContext ? { ...slotContext, wrapInAsset: false } : void 0
+      },
+      /* @__PURE__ */ React5.createElement("property", { name: "asset" }, normalizeToCollection({
+        node: props.children,
+        TextComp: switchContext?.TextComp,
+        CollectionComp: switchContext?.CollectionComp
+      }))
+    )
+  ));
+};
+Switch.Case = Case;
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/src/template.tsx
+import React6 from "react";
+import {
+  ArrayNode,
+  PropertyNode as PropertyNode2,
+  ValueNode,
+  createPortal,
+  ProxyNode,
+  toJSON
+} from "react-json-reconciler";
+var TemplateContext = React6.createContext({
+  depth: 0
+});
+function addTemplateToObject(obj, templateObj, templateParentNodeType) {
+  let templateProp = obj.properties.find(
+    (p) => p.keyNode.value === "template" && p.valueNode?.type === "array"
+  );
+  if (!templateProp) {
+    templateProp = new PropertyNode2(new ValueNode("template"), new ArrayNode());
+    templateProp.parent = obj;
+    obj.properties.push(templateProp);
+  }
+  const templateItems = templateProp.valueNode;
+  templateItems.items.push(templateObj);
+  templateObj.parent = templateItems;
+  const templateParentProp = obj.properties.find(
+    (p) => p.keyNode.value === templateParentNodeType && p.valueNode?.type === "array"
+  );
+  if (templateParentProp) {
+    const indexOfTemplateParent = obj.properties.indexOf(templateParentProp, 1);
+    const templateParentValueNode = obj.properties[indexOfTemplateParent]?.valueNode;
+    if (templateParentValueNode) {
+      const templateParentArray = toJSON(templateParentValueNode);
+      if (Array.isArray(templateParentArray) && templateParentArray.length === 0) {
+        obj.properties.splice(indexOfTemplateParent, 1);
+      }
+    }
+  }
+  return () => {
+    templateItems.items = templateItems.items.filter((t) => t !== templateObj);
+    if (templateItems.children.length === 0 && templateProp) {
+      obj.properties.splice(obj.properties.indexOf(templateProp, 1));
+    }
+  };
+}
+var TemplateProvider = (props) => {
+  const baseContext = React6.useContext(TemplateContext);
+  return /* @__PURE__ */ React6.createElement(TemplateContext.Provider, { value: { depth: baseContext.depth + 1 } }, props.children);
+};
+var getParentObject = (node) => {
+  if (node.type === "object") {
+    return node;
+  }
+  if (node.parent) {
+    return getParentObject(node.parent);
+  }
+};
+var getParentProperty = (node) => {
+  if (node.type === "property") {
+    return node;
+  }
+  if (node.parent) {
+    return getParentProperty(node.parent);
+  }
+};
+var Template = (props) => {
+  const baseContext = React6.useContext(TemplateContext);
+  const dynamicProp = props.dynamic ?? false;
+  const [outputProp, setOutputProp] = React6.useState(
+    props.output
+  );
+  const proxyRef = React6.useRef(null);
+  const valueRef = React6.useRef(null);
+  const outputElement = React6.useMemo(() => new ProxyNode(), []);
+  React6.useLayoutEffect(() => {
+    const propNode = proxyRef.current && getParentProperty(proxyRef.current);
+    if (outputProp === void 0 && propNode) {
+      setOutputProp(propNode.keyNode.value);
+    }
+  }, [proxyRef, outputProp]);
+  React6.useEffect(() => {
+    const templateObj = outputElement.items[0];
+    if (proxyRef.current) {
+      const parentObject = getParentObject(proxyRef.current);
+      if (!parentObject) {
+        throw new Error("Unable to find parent to add template to");
+      }
+      if (!outputProp) {
+        return;
+      }
+      return addTemplateToObject(parentObject, templateObj, outputProp);
+    }
+  }, [proxyRef, outputProp, outputElement.items]);
+  return /* @__PURE__ */ React6.createElement("proxy", { ref: proxyRef }, /* @__PURE__ */ React6.createElement(React6.Fragment, null, createPortal(
+    /* @__PURE__ */ React6.createElement(
+      OptionalIDSuffixProvider,
+      {
+        wrapperRef: valueRef,
+        templateIndex: `_index${baseContext.depth === 0 ? "" : baseContext.depth}_`
+      },
+      /* @__PURE__ */ React6.createElement(TemplateProvider, null, /* @__PURE__ */ React6.createElement("object", null, /* @__PURE__ */ React6.createElement("property", { name: "data" }, props.data.toValue()), /* @__PURE__ */ React6.createElement("property", { name: "output" }, outputProp), /* @__PURE__ */ React6.createElement("property", { name: "value" }, props.children), dynamicProp && /* @__PURE__ */ React6.createElement("property", { name: "dynamic" }, toJsonElement(dynamicProp))))
+    ),
+    outputElement
+  ), /* @__PURE__ */ React6.createElement("value", { ref: valueRef, value: void 0 })));
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/src/index.ts
+export * from "react-json-reconciler";
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/src/compiler/schema.ts
+import { dequal } from "dequal";
+import { SyncWaterfallHook } from "tapable-ts";
+var bindingSymbol = Symbol("binding");
+var SchemaTypeName = Symbol("Schema Rename");
+var isTypeDef = (property) => {
+  return property.type !== void 0;
+};
+var SchemaGenerator = class {
+  constructor(logger) {
+    this.hooks = {
+      createSchemaNode: new SyncWaterfallHook()
+    };
+    /**
+     * Converts an object to a `Schema.Schema` representation
+     * Note: uses iteration to prevent potentially very deep recursion on large objects
+     */
+    this.toSchema = (schema) => {
+      const newSchema = {
+        ROOT: {}
+      };
+      this.children = [];
+      this.generatedDataTypes.clear();
+      Object.keys(schema).forEach((property) => {
+        const subType = schema[property];
+        newSchema.ROOT[property] = this.hooks.createSchemaNode.call(
+          this.processChild(property, subType),
+          subType
+        );
+      });
+      while (this.children.length > 0) {
+        const c = this.children.pop();
+        if (c === void 0) {
+          break;
+        }
+        const { name, child } = c;
+        const typeDef = {};
+        Object.keys(child).forEach((property) => {
+          const subType = child[property];
+          typeDef[property] = this.hooks.createSchemaNode.call(
+            this.processChild(property, subType),
+            subType
+          );
+        });
+        newSchema[name] = typeDef;
+      }
+      return newSchema;
+    };
+    /**
+     * Make an intermediate `Schema.DataType` object given a name
+     */
+    this.makePlaceholderType = (typeName) => {
+      return {
+        type: `${typeName}Type`
+      };
+    };
+    this.children = [];
+    this.generatedDataTypes = /* @__PURE__ */ new Map();
+    this.logger = logger ?? console;
+  }
+  /**
+   * Processes the children of an object Node
+   * Newly discovered children get added to the provided array
+   */
+  processChild(property, subType) {
+    if (isTypeDef(subType)) {
+      return subType;
+    }
+    let intermediateType;
+    let child;
+    if (Array.isArray(subType)) {
+      if (subType.length > 1) {
+        this.logger.warn(
+          `Type ${property} has multiple types in array, should only contain one top level object type. Only taking first defined type`
+        );
+      }
+      const subTypeName = subType[0][SchemaTypeName] ?? property;
+      intermediateType = this.makePlaceholderArrayType(subTypeName);
+      [child] = subType;
+    } else {
+      const subTypeName = subType[SchemaTypeName] ?? property;
+      intermediateType = this.makePlaceholderType(subTypeName);
+      child = subType;
+    }
+    this.children.push({ name: intermediateType.type, child });
+    if (this.generatedDataTypes.has(intermediateType.type)) {
+      const generatedType = this.generatedDataTypes.get(
+        intermediateType.type
+      );
+      if (!dequal(
+        child,
+        this.generatedDataTypes.get(intermediateType.type)?.node
+      )) {
+        generatedType.count += 1;
+        const newIntermediateType = {
+          ...intermediateType,
+          type: `${intermediateType.type}${generatedType.count}`
+        };
+        this.logger.warn(
+          `WARNING: Generated two intermediate types with the name: ${intermediateType.type} that are of different shapes, using artificial type ${newIntermediateType.type}`
+        );
+        intermediateType = newIntermediateType;
+        this.children.pop();
+        this.children.push({ name: intermediateType.type, child });
+      }
+    }
+    this.generatedDataTypes.set(intermediateType.type, {
+      node: subType,
+      count: 1
+    });
+    return intermediateType;
+  }
+  /**
+   * Make an intermediate `Schema.DataType` object with array support given a name
+   */
+  makePlaceholderArrayType(typeName) {
+    return {
+      type: `${typeName}Type`,
+      isArray: true
+    };
+  }
+};
+function makeBindingsForObject(obj, arrayAccessorKeys = ["_index_"]) {
+  const accessor = (paths) => {
+    const bindingMap = /* @__PURE__ */ new WeakMap();
+    return {
+      ownKeys(target) {
+        return Reflect.ownKeys(target);
+      },
+      get(target, key) {
+        const bindingKeys = Object.keys(target);
+        if (Array.isArray(target[key]) && target[key].length > 0 && target[key].every((it) => typeof it !== "object")) {
+          return [...target[key]];
+        }
+        if (!bindingMap.has(target)) {
+          bindingMap.set(target, binding`${paths.join(".")}`);
+        }
+        if (key === bindingSymbol) {
+          return paths;
+        }
+        if (Array.isArray(target) && (arrayAccessorKeys.includes(key) || typeof key === "number")) {
+          return new Proxy(target[0], accessor(paths.concat([key])));
+        }
+        if (bindingKeys.includes(key) && typeof target[key] === "object") {
+          return new Proxy(target[key], accessor(paths.concat([key])));
+        }
+        const createdInstance = bindingMap.get(target);
+        return createdInstance?.[key];
+      }
+    };
+  };
+  return new Proxy(obj, accessor([]));
+}
+var getBindingFromObject = (obj) => {
+  const baseBindings = obj[bindingSymbol];
+  if (!Array.isArray(baseBindings) || baseBindings.length === 0) {
+    throw new Error(`Unable to get binding for ${obj}`);
+  }
+  return binding`${baseBindings.join(".")}`;
+};
+var getBindingStringFromObject = (obj) => {
+  return getBindingFromObject(obj).toString();
+};
+var getRefStringFromObject = (obj) => {
+  return getBindingFromObject(obj).toRefString();
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/src/compiler/compiler.ts
+import React8 from "react";
+import { SourceMapGenerator, SourceMapConsumer } from "source-map-js";
+import { render } from "react-json-reconciler";
+import {
+  AsyncSeriesHook,
+  AsyncSeriesWaterfallHook,
+  SyncHook
+} from "tapable-ts";
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/src/compiler/utils.ts
+import React7 from "react";
+var fingerprintContent = (content, filename) => {
+  if (content !== null || content !== void 0) {
+    if (React7.isValidElement(content)) {
+      return "view";
+    }
+    if (typeof content === "object" && "navigation" in content) {
+      return "flow";
+    }
+    if (!filename || filename.includes("schema")) {
+      return "schema";
+    }
+  }
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/src/compiler/compiler.ts
+var parseNavigationExpressions = (nav) => {
+  function replaceExpWithStr(obj) {
+    function convExp(value) {
+      return value && typeof value === "object" && value.__type === "expression" ? value.toValue() : replaceExpWithStr(value);
+    }
+    if (Array.isArray(obj)) {
+      return obj.map(convExp);
+    }
+    if (typeof obj === "object") {
+      const copy = { ...obj };
+      for (const [key, value] of Object.entries(copy)) {
+        copy[key] = convExp(value);
+      }
+      return copy;
+    }
+    return obj;
+  }
+  return replaceExpWithStr(nav);
+};
+var mergeSourceMaps = (sourceMaps, generated) => {
+  const generator = new SourceMapGenerator();
+  sourceMaps.forEach(({ sourceMap, offsetIndexSearch, source }) => {
+    const generatedLineOffset = generated.split("\n").findIndex((line) => line.includes(offsetIndexSearch));
+    const sourceLineOffset = source.split("\n").findIndex((line) => line.includes(offsetIndexSearch));
+    const lineOffset = generatedLineOffset - sourceLineOffset;
+    const generatedLine = generated.split("\n")[generatedLineOffset];
+    const sourceLine = source.split("\n")[sourceLineOffset];
+    const generatedColumn = generatedLine.indexOf(offsetIndexSearch);
+    const sourceColumn = sourceLine.indexOf(offsetIndexSearch);
+    const columnOffset = generatedColumn - sourceColumn;
+    const consumer = new SourceMapConsumer(JSON.parse(sourceMap));
+    consumer.eachMapping((mapping) => {
+      generator.addMapping({
+        generated: {
+          line: mapping.generatedLine + lineOffset,
+          column: mapping.generatedColumn + columnOffset
+        },
+        original: {
+          line: mapping.originalLine,
+          column: mapping.originalColumn
+        },
+        source: mapping.source
+      });
+    });
+  });
+  return generator.toString();
+};
+var DSLCompiler = class {
+  constructor(logger) {
+    this.hooks = {
+      // Hook to access the schema generator instance when initialized
+      schemaGenerator: new SyncHook(),
+      // Hook to access pre-compilation object
+      preProcessFlow: new AsyncSeriesWaterfallHook(),
+      // Hook to access post-compilation Flow before output is written
+      postProcessFlow: new AsyncSeriesWaterfallHook(),
+      // Hook called after all files are compiled. Revives the output directory
+      onEnd: new AsyncSeriesHook()
+    };
+    this.logger = logger ?? console;
+  }
+  /** Convert an object (flow, view, schema, etc) into it's JSON representation */
+  async serialize(value, context) {
+    if (typeof value !== "object" || value === null) {
+      throw new Error("Unable to serialize non-object");
+    }
+    const type = context?.type ? context.type : fingerprintContent(value);
+    if (!this.schemaGenerator) {
+      this.schemaGenerator = new SchemaGenerator(this.logger);
+      this.hooks.schemaGenerator.call(this.schemaGenerator);
+    }
+    if (type === "view") {
+      const { jsonValue, sourceMap } = await render(value, {
+        collectSourceMap: true
+      });
+      return {
+        value: jsonValue,
+        sourceMap
+      };
+    }
+    if (type === "flow") {
+      const allSourceMaps = [];
+      const copiedValue = {
+        ...value
+      };
+      copiedValue.views = await Promise.all(
+        copiedValue?.views?.map(async (node) => {
+          if (React8.isValidElement(node)) {
+            const { jsonValue, sourceMap, stringValue } = await render(node, {
+              collectSourceMap: true
+            });
+            if (sourceMap) {
+              const searchIdLine = stringValue.split("\n").find(
+                (line) => line.includes(
+                  `"id": "${jsonValue.id}"`
+                )
+              );
+              if (searchIdLine) {
+                allSourceMaps.push({
+                  sourceMap,
+                  offsetIndexSearch: searchIdLine,
+                  source: stringValue
+                });
+              }
+            }
+            return jsonValue;
+          }
+          return node;
+        }) ?? []
+      );
+      if ("navigation" in value) {
+        Object.entries(value.navigation).forEach(([navKey, node]) => {
+          if (typeof node === "object") {
+            Object.entries(node).forEach(([nodeKey, flowNode]) => {
+              if (flowNode && typeof flowNode === "object" && "state_type" in flowNode && flowNode.state_type === "VIEW" && React8.isValidElement(flowNode.ref)) {
+                const actualViewIndex = value.views?.indexOf?.(
+                  flowNode.ref
+                );
+                if (actualViewIndex !== void 0 && actualViewIndex > -1) {
+                  const actualId = copiedValue.views?.[actualViewIndex]?.id;
+                  copiedValue.navigation[navKey][nodeKey].ref = actualId;
+                }
+              }
+            });
+          }
+        });
+      }
+      if ("schema" in copiedValue) {
+        copiedValue.schema = this.schemaGenerator.toSchema(copiedValue.schema);
+      }
+      copiedValue.navigation = parseNavigationExpressions(
+        copiedValue.navigation
+      );
+      if (value) {
+        const postProcessFlow = await this.hooks.postProcessFlow.call(
+          copiedValue
+        );
+        return {
+          value: postProcessFlow,
+          sourceMap: mergeSourceMaps(
+            allSourceMaps,
+            JSON.stringify(copiedValue, null, 2)
+          )
+        };
+      }
+    }
+    return {
+      value: this.schemaGenerator.toSchema(value)
+    };
+  }
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/dsl/src/compiler/types.ts
+var DefaultCompilerContentTypes = ["view", "flow", "schema"];
+function isDefaultCompilerContentType(t) {
+  return DefaultCompilerContentTypes.includes(t);
+}
+export {
+  Asset,
+  AssetWrapper,
+  DSLCompiler,
+  GeneratedIDProperty,
+  IDProvider,
+  IDSuffixIndexProvider,
+  IDSuffixProvider,
+  IndexSuffixStopContext,
+  OptionalIDSuffixProvider,
+  SchemaGenerator,
+  SchemaTypeName,
+  Slot,
+  SlotContext,
+  Switch,
+  Template,
+  TemplateContext,
+  TemplateStringComponent,
+  View,
+  binding,
+  createSlot,
+  expression,
+  fingerprintContent,
+  flattenChildren,
+  getBindingFromObject,
+  getBindingStringFromObject,
+  getRefStringFromObject,
+  isDefaultCompilerContentType,
+  isTemplateStringInstance,
+  makeBindingsForObject,
+  normalizeText,
+  normalizeToCollection,
+  toArray,
+  toJsonElement,
+  toJsonProperties,
+  useGetIdPrefix,
+  useIndexInSlot
+};
+//# sourceMappingURL=index.mjs.map