@player-tools/dsl 0.0.2-next.0

package/dist/index.cjs.js

@@ -0,0 +1,865 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var flattenChildren = require('react-flatten-children');
+var mergeRefs = require('react-merge-refs');
+var reactJsonReconciler = require('react-json-reconciler');
+var signale = require('signale');
+var dequal = require('dequal');
+var tapableTs = require('tapable-ts');
+var sourceMapJs = require('source-map-js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+var flattenChildren__default = /*#__PURE__*/_interopDefaultLegacy(flattenChildren);
+var mergeRefs__default = /*#__PURE__*/_interopDefaultLegacy(mergeRefs);
+var signale__default = /*#__PURE__*/_interopDefaultLegacy(signale);
+
+const IDSuffixContext = React__default["default"].createContext("root");
+const IndexSuffixStopContext = React__default["default"].createContext(false);
+const useGetIdPrefix = () => {
+  return React__default["default"].useContext(IDSuffixContext);
+};
+const IDSuffixProvider = (props) => {
+  const currentPrefix = useGetIdPrefix();
+  return /* @__PURE__ */ React__default["default"].createElement(IDSuffixContext.Provider, {
+    value: [
+      currentPrefix === "root" ? void 0 : currentPrefix,
+      props.suffix
+    ].filter(Boolean).join("-")
+  }, props.children);
+};
+const IDProvider = (props) => {
+  if (props.id) {
+    return /* @__PURE__ */ React__default["default"].createElement(IDSuffixContext.Provider, {
+      value: props.id
+    }, props.children);
+  }
+  return /* @__PURE__ */ React__default["default"].createElement(React__default["default"].Fragment, null, props.children);
+};
+const useIndexInSlot = (ref) => {
+  const [index, setIndex] = React__default["default"].useState(-1);
+  const slotContext = React__default["default"].useContext(SlotContext);
+  React__default["default"].useEffect(() => {
+    var _a, _b;
+    if (!(slotContext == null ? void 0 : slotContext.isArray)) {
+      throw new Error("Cannot get index in non-array slot");
+    }
+    if (ref.current && ((_b = (_a = slotContext == null ? void 0 : slotContext.ref.current) == null ? void 0 : _a.valueNode) == null ? void 0 : _b.type) === "array") {
+      const allChildren = reactJsonReconciler.flattenNodes(slotContext.ref.current.valueNode.children);
+      const foundIndex = allChildren.indexOf(ref.current);
+      if (foundIndex !== index) {
+        setIndex(foundIndex);
+      }
+    }
+  }, [index, ref, slotContext == null ? void 0 : slotContext.isArray, slotContext == null ? void 0 : slotContext.ref]);
+  return index;
+};
+const IDSuffixIndexProvider = (props) => {
+  var _a;
+  const slotIndex = useIndexInSlot(props.wrapperRef);
+  const stopIndex = React__default["default"].useContext(IndexSuffixStopContext);
+  if (stopIndex) {
+    return /* @__PURE__ */ React__default["default"].createElement(React__default["default"].Fragment, null, props.children);
+  }
+  return /* @__PURE__ */ React__default["default"].createElement(IDSuffixProvider, {
+    suffix: (_a = props.templateIndex) != null ? _a : String(slotIndex)
+  }, /* @__PURE__ */ React__default["default"].createElement(IndexSuffixStopContext.Provider, {
+    value: true
+  }, props.children));
+};
+const OptionalIDSuffixProvider = (props) => {
+  const slotContext = React__default["default"].useContext(SlotContext);
+  if (slotContext == null ? void 0 : slotContext.isArray) {
+    return /* @__PURE__ */ React__default["default"].createElement(IDSuffixIndexProvider, {
+      wrapperRef: props.wrapperRef,
+      templateIndex: props.templateIndex
+    }, props.children);
+  }
+  return /* @__PURE__ */ React__default["default"].createElement(React__default["default"].Fragment, null, props.children);
+};
+
+var __defProp$4 = Object.defineProperty;
+var __defProps$3 = Object.defineProperties;
+var __getOwnPropDescs$3 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$4 = Object.getOwnPropertySymbols;
+var __hasOwnProp$4 = Object.prototype.hasOwnProperty;
+var __propIsEnum$4 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$4 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$4.call(b, prop))
+      __defNormalProp$4(a, prop, b[prop]);
+  if (__getOwnPropSymbols$4)
+    for (var prop of __getOwnPropSymbols$4(b)) {
+      if (__propIsEnum$4.call(b, prop))
+        __defNormalProp$4(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
+const OpaqueIdentifier = Symbol("TemplateStringType");
+const TemplateStringComponent = (props) => {
+  return React__default["default"].createElement("value", {
+    value: props.value
+  }, null);
+};
+const createTemplateInstance = (options) => {
+  const value = options.strings.reduce((sum, next, i) => {
+    var _a;
+    const element2 = options.other[i];
+    if (typeof element2 === "string") {
+      return sum + next + element2;
+    }
+    return sum + next + ((_a = element2 == null ? void 0 : element2.toRefString(options)) != null ? _a : "");
+  }, "");
+  const toString = () => {
+    return options.toRefString({}, value);
+  };
+  const toValue = () => {
+    return value;
+  };
+  const element = React__default["default"].createElement(TemplateStringComponent, {
+    value: toString()
+  }, null);
+  return __spreadProps$3(__spreadValues$4({}, element), {
+    [OpaqueIdentifier]: true,
+    toString,
+    toValue,
+    toRefString: (refStringOptions) => {
+      return options.toRefString(refStringOptions, value);
+    }
+  });
+};
+const createBindingTemplateInstance = (options) => {
+  const templateInstance = createTemplateInstance(__spreadProps$3(__spreadValues$4({}, options), {
+    toRefString: (context, value) => {
+      return `{{${value}}}`;
+    }
+  }));
+  templateInstance.__type = "binding";
+  return templateInstance;
+};
+const createExpressionTemplateInstance = (options) => {
+  const templateInstance = createTemplateInstance(__spreadProps$3(__spreadValues$4({}, options), {
+    toRefString: (contextOptions, value) => {
+      if ((contextOptions == null ? void 0 : contextOptions.nestedContext) === "expression") {
+        return value;
+      }
+      const inBinding = (contextOptions == null ? void 0 : contextOptions.nestedContext) === "binding";
+      return `${inBinding ? "`" : "@["}${value}${inBinding ? "`" : "]@"}`;
+    }
+  }));
+  templateInstance.__type = "expression";
+  return templateInstance;
+};
+const binding = (strings, ...nested) => {
+  return createBindingTemplateInstance({
+    strings,
+    other: nested,
+    nestedContext: "binding"
+  });
+};
+const expression = (strings, ...nested) => {
+  return createExpressionTemplateInstance({
+    strings,
+    other: nested,
+    nestedContext: "expression"
+  });
+};
+const isTemplateStringInstance = (val) => {
+  return typeof val === "object" && val[OpaqueIdentifier] === true;
+};
+
+var __defProp$3 = Object.defineProperty;
+var __defProps$2 = Object.defineProperties;
+var __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$3 = Object.getOwnPropertySymbols;
+var __hasOwnProp$3 = Object.prototype.hasOwnProperty;
+var __propIsEnum$3 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$3 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$3.call(b, prop))
+      __defNormalProp$3(a, prop, b[prop]);
+  if (__getOwnPropSymbols$3)
+    for (var prop of __getOwnPropSymbols$3(b)) {
+      if (__propIsEnum$3.call(b, prop))
+        __defNormalProp$3(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
+function toArray(val) {
+  return Array.isArray(val) ? val : [val];
+}
+function toJsonElement(value, index) {
+  const keyProp = index === void 0 ? null : { key: index };
+  if (Array.isArray(value)) {
+    return /* @__PURE__ */ React__default["default"].createElement("array", __spreadValues$3({}, keyProp), value.map((item, idx) => toJsonElement(item, idx)));
+  }
+  if (isTemplateStringInstance(value)) {
+    return /* @__PURE__ */ React__default["default"].createElement("value", __spreadValues$3({}, keyProp), value.toRefString());
+  }
+  if (typeof value === "object" && value !== null) {
+    return /* @__PURE__ */ React__default["default"].createElement("obj", __spreadValues$3({}, keyProp), Object.keys(value).map((key) => /* @__PURE__ */ React__default["default"].createElement("property", {
+      key,
+      name: key
+    }, toJsonElement(value[key]))));
+  }
+  return /* @__PURE__ */ React__default["default"].createElement("value", __spreadProps$2(__spreadValues$3({}, keyProp), {
+    value
+  }));
+}
+function toJsonProperties(value) {
+  return Object.keys(value).map((key) => /* @__PURE__ */ React__default["default"].createElement("property", {
+    key,
+    name: key
+  }, toJsonElement(value[key])));
+}
+function normalizeText(options) {
+  const { node, TextComp } = options;
+  const nodeArr = React__default["default"].Children.toArray(node);
+  if (nodeArr.every((n) => React__default["default"].isValidElement(n) && n.type !== TemplateStringComponent)) {
+    return node;
+  }
+  if (TextComp) {
+    return /* @__PURE__ */ React__default["default"].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 (React__default["default"].Children.count(node) > 1 && React__default["default"].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__ */ React__default["default"].createElement(CollectionComp, null, node);
+  }
+  return normalizeText(__spreadProps$2(__spreadValues$3({}, options), { node }));
+}
+
+var __defProp$2 = Object.defineProperty;
+var __defProps$1 = Object.defineProperties;
+var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
+var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
+var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$2 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$2.call(b, prop))
+      __defNormalProp$2(a, prop, b[prop]);
+  if (__getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(b)) {
+      if (__propIsEnum$2.call(b, prop))
+        __defNormalProp$2(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$2.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$2.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+const SlotContext = React__default["default"].createContext(void 0);
+const AssetWrapper = React__default["default"].forwardRef((props, ref) => {
+  const _a = props, { children } = _a, rest = __objRest(_a, ["children"]);
+  return /* @__PURE__ */ React__default["default"].createElement("obj", {
+    ref
+  }, toJsonProperties(rest), /* @__PURE__ */ React__default["default"].createElement("property", {
+    name: "asset"
+  }, children));
+});
+const GeneratedIDProperty = (props) => {
+  var _a;
+  const currentPrefixId = useGetIdPrefix();
+  return /* @__PURE__ */ React__default["default"].createElement("property", {
+    name: "id"
+  }, (_a = props.id) != null ? _a : currentPrefixId);
+};
+const Asset = React__default["default"].forwardRef((props, ref) => {
+  const _a = props, { id, type, applicability, children } = _a, rest = __objRest(_a, ["id", "type", "applicability", "children"]);
+  const slotContext = React__default["default"].useContext(SlotContext);
+  const localRef = React__default["default"].useRef(null);
+  const Wrapper = (slotContext == null ? void 0 : slotContext.wrapInAsset) ? AssetWrapper : React__default["default"].Fragment;
+  return /* @__PURE__ */ React__default["default"].createElement(Wrapper, __spreadValues$2({
+    ref: (slotContext == null ? void 0 : slotContext.wrapInAsset) ? mergeRefs__default["default"]([ref, localRef]) : void 0
+  }, (slotContext == null ? void 0 : slotContext.wrapInAsset) && (slotContext == null ? void 0 : slotContext.additionalProperties) ? slotContext == null ? void 0 : slotContext.additionalProperties : {}), /* @__PURE__ */ React__default["default"].createElement(OptionalIDSuffixProvider, {
+    wrapperRef: localRef
+  }, /* @__PURE__ */ React__default["default"].createElement(SlotContext.Provider, {
+    value: void 0
+  }, /* @__PURE__ */ React__default["default"].createElement(IDProvider, {
+    id
+  }, /* @__PURE__ */ React__default["default"].createElement("obj", {
+    ref: (slotContext == null ? void 0 : slotContext.wrapInAsset) ? void 0 : mergeRefs__default["default"]([ref, localRef])
+  }, /* @__PURE__ */ React__default["default"].createElement(GeneratedIDProperty, {
+    id
+  }), /* @__PURE__ */ React__default["default"].createElement("property", {
+    name: "type"
+  }, type), applicability !== void 0 && /* @__PURE__ */ React__default["default"].createElement("property", {
+    name: "applicability"
+  }, /* @__PURE__ */ React__default["default"].createElement("value", {
+    value: typeof applicability === "boolean" ? applicability : applicability.toRefString()
+  })), toJsonProperties(rest), children)))));
+});
+Asset.defaultProps = {
+  id: void 0,
+  children: void 0
+};
+const Slot = (props) => {
+  var _a, _b;
+  const { TextComp, CollectionComp } = props;
+  const children = flattenChildren__default["default"](props.children);
+  const propRef = React__default["default"].useRef(null);
+  return /* @__PURE__ */ React__default["default"].createElement("property", {
+    ref: propRef,
+    name: props.name
+  }, /* @__PURE__ */ React__default["default"].createElement(IDSuffixProvider, {
+    suffix: props.name
+  }, /* @__PURE__ */ React__default["default"].createElement(IndexSuffixStopContext.Provider, {
+    value: false
+  }, /* @__PURE__ */ React__default["default"].createElement(SlotContext.Provider, {
+    value: {
+      ref: propRef,
+      propertyName: props.name,
+      wrapInAsset: (_a = props.wrapInAsset) != null ? _a : false,
+      isArray: (_b = props.isArray) != null ? _b : false,
+      additionalProperties: props.additionalProperties,
+      TextComp,
+      CollectionComp
+    }
+  }, props.isArray && /* @__PURE__ */ React__default["default"].createElement("array", null, React__default["default"].Children.map(children, (child, index) => {
+    return /* @__PURE__ */ React__default["default"].createElement(React__default["default"].Fragment, {
+      key: `${props.name}-${index}`
+    }, normalizeText({ node: child, TextComp }));
+  })), !props.isArray && normalizeToCollection({
+    node: children,
+    TextComp,
+    CollectionComp
+  })))));
+};
+function createSlot(options) {
+  return (props) => {
+    const _a = props, { children } = _a, other = __objRest(_a, ["children"]);
+    return /* @__PURE__ */ React__default["default"].createElement(Slot, __spreadProps$1(__spreadValues$2({}, options), {
+      additionalProperties: other
+    }), children);
+  };
+}
+
+var __defProp$1 = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+const SwitchContext = React__default["default"].createContext({});
+const Switch = (props) => {
+  const slotContext = React__default["default"].useContext(SlotContext);
+  const propertyNode = React__default["default"].useRef(null);
+  return /* @__PURE__ */ React__default["default"].createElement("obj", {
+    ref: propertyNode
+  }, /* @__PURE__ */ React__default["default"].createElement(SwitchContext.Provider, {
+    value: __spreadProps(__spreadValues$1({}, props), {
+      TextComp: slotContext == null ? void 0 : slotContext.TextComp,
+      CollectionComp: slotContext == null ? void 0 : slotContext.CollectionComp
+    })
+  }, /* @__PURE__ */ React__default["default"].createElement(OptionalIDSuffixProvider, {
+    wrapperRef: propertyNode
+  }, /* @__PURE__ */ React__default["default"].createElement("property", {
+    name: props.isDynamic ? "dynamicSwitch" : "staticSwitch"
+  }, /* @__PURE__ */ React__default["default"].createElement(SlotContext.Provider, {
+    value: void 0
+  }, /* @__PURE__ */ React__default["default"].createElement("array", null, props.children))))), (slotContext == null ? void 0 : slotContext.additionalProperties) && toJsonProperties(slotContext.additionalProperties));
+};
+const findParentArray = (node) => {
+  if (node.type === "array") {
+    return node;
+  }
+  if (node.parent) {
+    return findParentArray(node.parent);
+  }
+  throw new Error("can't find parent array");
+};
+const findArrayIndex = (node) => {
+  const parentArray = findParentArray(node);
+  const allSearch = reactJsonReconciler.flattenNodes(parentArray.children);
+  return allSearch.indexOf(node);
+};
+const Case = (props) => {
+  const slotContext = React__default["default"].useContext(SlotContext);
+  const switchContext = React__default["default"].useContext(SwitchContext);
+  const [caseIndex, setCaseIndex] = React__default["default"].useState(-1);
+  const caseNode = React__default["default"].useRef(null);
+  React__default["default"].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__ */ React__default["default"].createElement("obj", {
+    ref: caseNode
+  }, /* @__PURE__ */ React__default["default"].createElement("property", {
+    name: "case"
+  }, /* @__PURE__ */ React__default["default"].createElement("value", {
+    value: expValue
+  })), /* @__PURE__ */ React__default["default"].createElement(IDSuffixProvider, {
+    suffix: `${switchContext.isDynamic ? "dynamicSwitch" : "staticSwitch"}-${caseIndex}`
+  }, /* @__PURE__ */ React__default["default"].createElement(SlotContext.Provider, {
+    value: slotContext ? __spreadProps(__spreadValues$1({}, slotContext), { wrapInAsset: false }) : void 0
+  }, /* @__PURE__ */ React__default["default"].createElement("property", {
+    name: "asset"
+  }, normalizeToCollection({
+    node: props.children,
+    TextComp: switchContext == null ? void 0 : switchContext.TextComp,
+    CollectionComp: switchContext == null ? void 0 : switchContext.CollectionComp
+  })))));
+};
+Switch.Case = Case;
+
+const TemplateContext = React__default["default"].createContext({
+  depth: 0
+});
+function addTemplateToObject(obj, templateObj, templateParentNodeType) {
+  var _a;
+  let templateProp = obj.properties.find((p) => {
+    var _a2;
+    return p.keyNode.value === "template" && ((_a2 = p.valueNode) == null ? void 0 : _a2.type) === "array";
+  });
+  if (!templateProp) {
+    templateProp = new reactJsonReconciler.PropertyNode(new reactJsonReconciler.ValueNode("template"), new reactJsonReconciler.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) => {
+    var _a2;
+    return p.keyNode.value === templateParentNodeType && ((_a2 = p.valueNode) == null ? void 0 : _a2.type) === "array";
+  });
+  if (templateParentProp) {
+    const indexOfTemplateParent = obj.properties.indexOf(templateParentProp, 1);
+    const templateParentValueNode = (_a = obj.properties[indexOfTemplateParent]) == null ? void 0 : _a.valueNode;
+    if (templateParentValueNode) {
+      const templateParentArray = reactJsonReconciler.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));
+    }
+  };
+}
+const TemplateProvider = (props) => {
+  const baseContext = React__default["default"].useContext(TemplateContext);
+  return /* @__PURE__ */ React__default["default"].createElement(TemplateContext.Provider, {
+    value: { depth: baseContext.depth + 1 }
+  }, props.children);
+};
+const getParentObject = (node) => {
+  if (node.type === "object") {
+    return node;
+  }
+  if (node.parent) {
+    return getParentObject(node.parent);
+  }
+};
+const getParentProperty = (node) => {
+  if (node.type === "property") {
+    return node;
+  }
+  if (node.parent) {
+    return getParentProperty(node.parent);
+  }
+};
+const Template = (props) => {
+  const baseContext = React__default["default"].useContext(TemplateContext);
+  const [outputProp, setOutputProp] = React__default["default"].useState(props.output);
+  const proxyRef = React__default["default"].useRef(null);
+  const valueRef = React__default["default"].useRef(null);
+  const outputElement = React__default["default"].useMemo(() => new reactJsonReconciler.ProxyNode(), []);
+  React__default["default"].useLayoutEffect(() => {
+    const propNode = proxyRef.current && getParentProperty(proxyRef.current);
+    if (outputProp === void 0 && propNode) {
+      setOutputProp(propNode.keyNode.value);
+    }
+  }, [proxyRef, outputProp]);
+  React__default["default"].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__ */ React__default["default"].createElement("proxy", {
+    ref: proxyRef
+  }, reactJsonReconciler.createPortal(/* @__PURE__ */ React__default["default"].createElement(OptionalIDSuffixProvider, {
+    wrapperRef: valueRef,
+    templateIndex: `_index${baseContext.depth === 0 ? "" : baseContext.depth}_`
+  }, /* @__PURE__ */ React__default["default"].createElement(TemplateProvider, null, /* @__PURE__ */ React__default["default"].createElement("object", null, /* @__PURE__ */ React__default["default"].createElement("property", {
+    name: "data"
+  }, props.data.toValue()), /* @__PURE__ */ React__default["default"].createElement("property", {
+    name: "output"
+  }, outputProp), /* @__PURE__ */ React__default["default"].createElement("property", {
+    name: "value"
+  }, props.children)))), outputElement), /* @__PURE__ */ React__default["default"].createElement("value", {
+    ref: valueRef,
+    value: void 0
+  }));
+};
+
+const bindingSymbol = Symbol("binding");
+const SchemaTypeName = Symbol("Schema Rename");
+const isTypeDef = (property) => {
+  return property.type !== void 0;
+};
+class SchemaGenerator {
+  constructor() {
+    this.hooks = {
+      createSchemaNode: new tapableTs.SyncWaterfallHook()
+    };
+    this.toSchema = (schema) => {
+      const newSchema = {
+        ROOT: {}
+      };
+      this.children = [];
+      this.generatedDataTypeNames.clear();
+      Object.keys(schema).forEach((property) => {
+        const subType = schema[property];
+        newSchema.ROOT[property] = this.hooks.createSchemaNode.call(this.processChildren(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.processChildren(property, subType), subType);
+        });
+        newSchema[name] = typeDef;
+      }
+      return newSchema;
+    };
+    this.makePlaceholderType = (typeName) => {
+      return {
+        type: `${typeName}Type`
+      };
+    };
+    this.children = [];
+    this.generatedDataTypeNames = new Map();
+  }
+  processChildren(property, subType) {
+    var _a, _b;
+    if (isTypeDef(subType)) {
+      return subType;
+    }
+    let intermediateType;
+    if (Array.isArray(subType)) {
+      if (subType.length > 1) {
+        signale__default["default"].warn(`Type ${property} has multiple types in array, should only contain one top level object type. Only taking first defined type`);
+      }
+      const subTypeName = (_a = subType[0][SchemaTypeName]) != null ? _a : property;
+      intermediateType = this.makePlaceholderArrayType(subTypeName);
+      this.children.push({ name: intermediateType.type, child: subType[0] });
+    } else {
+      const subTypeName = (_b = subType[SchemaTypeName]) != null ? _b : property;
+      intermediateType = this.makePlaceholderType(subTypeName);
+      this.children.push({ name: intermediateType.type, child: subType });
+    }
+    if (this.generatedDataTypeNames.has(intermediateType.type)) {
+      if (!dequal.dequal(subType, this.generatedDataTypeNames.get(intermediateType.type))) {
+        throw new Error(`Error: Generated two intermediate types with the name: ${intermediateType.type} that are of different shapes`);
+      }
+      this.children.pop();
+    }
+    this.generatedDataTypeNames.set(intermediateType.type, subType);
+    return intermediateType;
+  }
+  makePlaceholderArrayType(typeName) {
+    return {
+      type: `${typeName}Type`,
+      isArray: true
+    };
+  }
+}
+function makeBindingsForObject(obj, arrayAccessorKeys = ["_index_"]) {
+  const accessor = (paths) => {
+    const bindingMap = new WeakMap();
+    return {
+      ownKeys(target) {
+        return Reflect.ownKeys(target);
+      },
+      get(target, key) {
+        const bindingKeys = Object.keys(target);
+        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 == null ? void 0 : createdInstance[key];
+      }
+    };
+  };
+  return new Proxy(obj, accessor([]));
+}
+const 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(".")}`;
+};
+const getBindingStringFromObject = (obj) => {
+  return getBindingFromObject(obj).toString();
+};
+const getRefStringFromObject = (obj) => {
+  return getBindingFromObject(obj).toRefString();
+};
+
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+const 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") {
+      return Object.fromEntries(Object.entries(obj).map(([key, value]) => [key, convExp(value)]));
+    }
+    return obj;
+  }
+  return replaceExpWithStr(nav);
+};
+const mergeSourceMaps = (sourceMaps, generated) => {
+  const generator = new sourceMapJs.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 sourceMapJs.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();
+};
+class DSLCompiler {
+  constructor() {
+    this.hooks = {
+      schemaGenerator: new tapableTs.SyncHook()
+    };
+  }
+  serialize(value) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      if (typeof value !== "object" || value === null) {
+        throw new Error("Unable to serialize non-object");
+      }
+      if (React__default["default"].isValidElement(value)) {
+        const { jsonValue, sourceMap } = yield reactJsonReconciler.render(value, {
+          collectSourceMap: true
+        });
+        return {
+          value: jsonValue,
+          sourceMap,
+          contentType: "view"
+        };
+      }
+      if ("navigation" in value) {
+        const allSourceMaps = [];
+        const copiedValue = __spreadValues({}, value);
+        copiedValue.views = yield Promise.all((_b = (_a = copiedValue == null ? void 0 : copiedValue.views) == null ? void 0 : _a.map((node) => __async(this, null, function* () {
+          const { jsonValue, sourceMap, stringValue } = yield reactJsonReconciler.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;
+        }))) != null ? _b : []);
+        if ("navigation" in value) {
+          Object.entries(value.navigation).forEach(([navKey, node]) => {
+            if (typeof node === "object") {
+              Object.entries(node).forEach(([nodeKey, flowNode]) => {
+                var _a2, _b2, _c, _d;
+                if (flowNode && typeof flowNode === "object" && "state_type" in flowNode && flowNode.state_type === "VIEW" && React__default["default"].isValidElement(flowNode.ref)) {
+                  const actualViewIndex = (_b2 = (_a2 = value.views) == null ? void 0 : _a2.indexOf) == null ? void 0 : _b2.call(_a2, flowNode.ref);
+                  if (actualViewIndex !== void 0 && actualViewIndex > -1) {
+                    const actualId = (_d = (_c = copiedValue.views) == null ? void 0 : _c[actualViewIndex]) == null ? void 0 : _d.id;
+                    copiedValue.navigation[navKey][nodeKey].ref = actualId;
+                  }
+                }
+              });
+            }
+          });
+          copiedValue.navigation = parseNavigationExpressions(copiedValue.navigation);
+        }
+        if (value) {
+          return {
+            value: copiedValue,
+            contentType: "flow",
+            sourceMap: mergeSourceMaps(allSourceMaps, JSON.stringify(copiedValue, null, 2))
+          };
+        }
+      }
+      const schemaGenerator = new SchemaGenerator();
+      this.hooks.schemaGenerator.call(schemaGenerator);
+      return {
+        value: schemaGenerator.toSchema(value),
+        contentType: "schema"
+      };
+    });
+  }
+}
+
+exports.Asset = Asset;
+exports.AssetWrapper = AssetWrapper;
+exports.DSLCompiler = DSLCompiler;
+exports.GeneratedIDProperty = GeneratedIDProperty;
+exports.IDProvider = IDProvider;
+exports.IDSuffixIndexProvider = IDSuffixIndexProvider;
+exports.IDSuffixProvider = IDSuffixProvider;
+exports.IndexSuffixStopContext = IndexSuffixStopContext;
+exports.OptionalIDSuffixProvider = OptionalIDSuffixProvider;
+exports.SchemaGenerator = SchemaGenerator;
+exports.SchemaTypeName = SchemaTypeName;
+exports.Slot = Slot;
+exports.SlotContext = SlotContext;
+exports.Switch = Switch;
+exports.Template = Template;
+exports.TemplateContext = TemplateContext;
+exports.TemplateStringComponent = TemplateStringComponent;
+exports.binding = binding;
+exports.createSlot = createSlot;
+exports.expression = expression;
+exports.getBindingFromObject = getBindingFromObject;
+exports.getBindingStringFromObject = getBindingStringFromObject;
+exports.getRefStringFromObject = getRefStringFromObject;
+exports.isTemplateStringInstance = isTemplateStringInstance;
+exports.makeBindingsForObject = makeBindingsForObject;
+exports.normalizeText = normalizeText;
+exports.normalizeToCollection = normalizeToCollection;
+exports.toArray = toArray;
+exports.toJsonElement = toJsonElement;
+exports.toJsonProperties = toJsonProperties;
+exports.useGetIdPrefix = useGetIdPrefix;
+exports.useIndexInSlot = useIndexInSlot;
+Object.keys(reactJsonReconciler).forEach(function (k) {
+  if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return reactJsonReconciler[k]; }
+  });
+});
+//# sourceMappingURL=index.cjs.js.map