@xlr-lib/xlr-utils 0.1.1--canary.9.190

package/dist/cjs/index.cjs

@@ -0,0 +1,507 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/utils/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  applyExcludeToNodeType: () => applyExcludeToNodeType,
+  applyPartialOrRequiredToNodeType: () => applyPartialOrRequiredToNodeType,
+  applyPickOrOmitToNodeType: () => applyPickOrOmitToNodeType,
+  computeEffectiveObject: () => computeEffectiveObject,
+  computeExtends: () => computeExtends,
+  fillInGenerics: () => fillInGenerics,
+  isAndType: () => isAndType,
+  isArrayType: () => isArrayType,
+  isBooleanType: () => isBooleanType,
+  isGenericNamedType: () => isGenericNamedType,
+  isGenericNodeType: () => isGenericNodeType,
+  isNamedType: () => isNamedType,
+  isNode: () => isNode,
+  isNonNullable: () => isNonNullable,
+  isNumberType: () => isNumberType,
+  isObjectType: () => isObjectType,
+  isOrType: () => isOrType,
+  isPrimitiveTypeNode: () => isPrimitiveTypeNode,
+  isRecordType: () => isRecordType,
+  isRefType: () => isRefType,
+  isStringType: () => isStringType,
+  makePropertyMap: () => makePropertyMap,
+  propertyToTuple: () => propertyToTuple,
+  resolveConditional: () => resolveConditional,
+  resolveReferenceNode: () => resolveReferenceNode
+});
+module.exports = __toCommonJS(src_exports);
+
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/utils/src/type-checks.ts
+function isGenericNodeType(nt) {
+  return nt.genericTokens?.length > 0;
+}
+function isGenericNamedType(nt) {
+  return nt.genericTokens?.length > 0;
+}
+function isPrimitiveTypeNode(node) {
+  return node.type === "string" || node.type === "number" || node.type === "boolean" || node.type === "null" || node.type === "any" || node.type === "never" || node.type === "undefined" || node.type === "unknown" || node.type === "void";
+}
+function isNonNullable(a) {
+  return a !== null || a !== void 0;
+}
+function isStringType(node) {
+  return node.type === "string";
+}
+function isNumberType(node) {
+  return node.type === "number";
+}
+function isBooleanType(node) {
+  return node.type === "boolean";
+}
+function isObjectType(node) {
+  return node.type === "object";
+}
+function isArrayType(node) {
+  return node.type === "array";
+}
+function isRefType(node) {
+  return node.type === "ref";
+}
+function isOrType(node) {
+  return node.type === "or";
+}
+function isAndType(node) {
+  return node.type === "and";
+}
+function isRecordType(node) {
+  return node.type === "record";
+}
+function isNamedType(node) {
+  return "name" in node && "source" in node && typeof node.name === "string";
+}
+
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/utils/src/validation-helpers.ts
+function propertyToTuple(node) {
+  return {
+    key: node.children?.[0].value,
+    value: node.children?.[1]
+  };
+}
+function makePropertyMap(node) {
+  const m = /* @__PURE__ */ new Map();
+  node.children?.forEach((child) => {
+    const property = propertyToTuple(child);
+    m.set(property.key, property.value);
+  });
+  return m;
+}
+function isNode(obj) {
+  return typeof obj !== "string" || typeof obj !== "number" || typeof obj !== "boolean";
+}
+function computeExtends(a, b) {
+  if ((a.type === "any" || a.type === "unknown") && (b.type === "any" || b.type === "unknown")) {
+    return true;
+  }
+  if ((a.type === "null" || a.type === "undefined") && (b.type === "null" || b.type === "undefined")) {
+    return true;
+  }
+  if (a.type === b.type) {
+    if (isPrimitiveTypeNode(a) && isPrimitiveTypeNode(b)) {
+      if (a.const && b.const) {
+        if (a.const === b.const) {
+          return true;
+        }
+      } else {
+        return true;
+      }
+    }
+    if (a.type === "ref" && b.type === "ref") {
+      return a.ref === b.ref;
+    }
+    if (a.type === "object" && b.type === "object") {
+      for (const property in b.properties) {
+        const propertyNode = b.properties[property];
+        if (!a.properties[property] || !computeExtends(a.properties[property].node, propertyNode.node)) {
+          return false;
+        }
+      }
+      return true;
+    }
+  }
+  if (isPrimitiveTypeNode(a) && b.type === "or") {
+    return b.or.every((member) => computeExtends(a, member));
+  }
+  if (isPrimitiveTypeNode(b) && a.type === "or") {
+    return a.or.every((member) => computeExtends(b, member));
+  }
+  if (a.type === "or" && b.type === "or") {
+    return a.or.every((x) => b.or.some((y) => computeExtends(x, y)));
+  }
+  return false;
+}
+function resolveConditional(conditional) {
+  const { left, right } = conditional.check;
+  const conditionalResult = computeExtends(left, right) ? conditional.value.true : conditional.value.false;
+  if (isGenericNodeType(conditional)) {
+    const genericMap = /* @__PURE__ */ new Map();
+    conditional.genericTokens.forEach((token) => {
+      genericMap.set(
+        token.symbol,
+        token.default ?? token.constraints ?? { type: "any" }
+      );
+    });
+    return fillInGenerics(conditionalResult, genericMap);
+  }
+  return conditionalResult;
+}
+function resolveReferenceNode(genericReference, typeToFill) {
+  const genericArgs = genericReference.genericArguments;
+  const genericMap = /* @__PURE__ */ new Map();
+  if (genericArgs && isGenericNodeType(typeToFill)) {
+    typeToFill.genericTokens.forEach((token, index) => {
+      genericMap.set(
+        token.symbol,
+        genericArgs[index] ?? token.default ?? token.constraints
+      );
+    });
+  }
+  const filledInNode = fillInGenerics(typeToFill, genericMap);
+  if (isGenericNodeType(filledInNode) && genericArgs?.length) {
+    if (genericArgs.length < filledInNode.genericTokens.length) {
+      filledInNode.genericTokens = filledInNode.genericTokens.slice(
+        genericArgs?.length
+      );
+    } else if (genericArgs.length === filledInNode.genericTokens.length) {
+      filledInNode.genericTokens = [];
+    }
+  }
+  if (genericReference.property && filledInNode.type === "object") {
+    return filledInNode.properties[genericReference.property]?.node ?? filledInNode.additionalProperties ?? { type: "undefined" };
+  }
+  return filledInNode;
+}
+function computeEffectiveObject(base, operand, errorOnOverlap = true) {
+  const baseObjectName = base.name ?? base.title ?? "object literal";
+  const operandObjectName = operand.name ?? operand.title ?? "object literal";
+  const newObject = {
+    ...JSON.parse(JSON.stringify(base)),
+    name: `${baseObjectName} & ${operandObjectName}`,
+    description: `Effective type combining ${baseObjectName} and ${operandObjectName}`,
+    genericTokens: [
+      ...isGenericNodeType(base) ? base.genericTokens : [],
+      ...isGenericNodeType(operand) ? operand.genericTokens : []
+    ]
+  };
+  for (const property in operand.properties) {
+    if (newObject.properties[property] !== void 0 && errorOnOverlap) {
+      if (!computeExtends(
+        newObject.properties[property].node,
+        operand.properties[property].node
+      )) {
+        throw new Error(
+          `Can't compute effective type for ${baseObjectName} and ${operandObjectName} because of conflicting properties ${property}`
+        );
+      }
+    }
+    newObject.properties[property] = operand.properties[property];
+  }
+  if (newObject.additionalProperties && operand.additionalProperties) {
+    if (!isPrimitiveTypeNode(newObject.additionalProperties) || !isPrimitiveTypeNode(operand.additionalProperties) || newObject.additionalProperties.type !== operand.additionalProperties.type) {
+      newObject.additionalProperties = {
+        type: "and",
+        and: [newObject.additionalProperties, operand.additionalProperties]
+      };
+    }
+  } else if (operand.additionalProperties) {
+    newObject.additionalProperties = operand.additionalProperties;
+  }
+  return newObject;
+}
+
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/utils/src/xlr-helpers.ts
+function fillInGenerics(xlrNode, generics, preferLocalGenerics = false) {
+  let localGenerics;
+  if (generics) {
+    localGenerics = new Map(generics);
+    if (preferLocalGenerics && isGenericNodeType(xlrNode)) {
+      xlrNode.genericTokens?.forEach((token) => {
+        const genericValue = token.default ?? token.constraints;
+        localGenerics.set(
+          token.symbol,
+          fillInGenerics(genericValue, localGenerics, preferLocalGenerics)
+        );
+      });
+    }
+  } else {
+    localGenerics = /* @__PURE__ */ new Map();
+    if (isGenericNodeType(xlrNode)) {
+      xlrNode.genericTokens?.forEach((token) => {
+        const genericValue = token.default ?? token.constraints;
+        localGenerics.set(
+          token.symbol,
+          fillInGenerics(genericValue, localGenerics, preferLocalGenerics)
+        );
+      });
+    }
+  }
+  if (xlrNode.type === "ref") {
+    if (localGenerics.has(xlrNode.ref)) {
+      return {
+        ...localGenerics.get(xlrNode.ref),
+        ...xlrNode.genericArguments ? {
+          genericArguments: xlrNode.genericArguments.map(
+            (ga) => fillInGenerics(ga, localGenerics, preferLocalGenerics)
+          )
+        } : {},
+        ...xlrNode.title ? { title: xlrNode.title } : {},
+        ...xlrNode.name ? { name: xlrNode.name } : {},
+        ...xlrNode.description ? { description: xlrNode.description } : {},
+        ...xlrNode.comment ? { comment: xlrNode.comment } : {}
+      };
+    }
+    return {
+      ...xlrNode,
+      ...xlrNode.genericArguments ? {
+        genericArguments: xlrNode.genericArguments.map(
+          (ga) => fillInGenerics(ga, localGenerics, preferLocalGenerics)
+        )
+      } : {}
+    };
+  }
+  if (xlrNode.type === "object") {
+    const newProperties = {};
+    Object.getOwnPropertyNames(xlrNode.properties).forEach((propName) => {
+      const prop = xlrNode.properties[propName];
+      newProperties[propName] = {
+        required: prop.required,
+        node: fillInGenerics(prop.node, localGenerics, preferLocalGenerics)
+      };
+    });
+    return {
+      ...xlrNode,
+      properties: newProperties,
+      ...isGenericNamedType(xlrNode) ? {
+        genericTokens: xlrNode.genericTokens.map((token) => {
+          return {
+            ...token,
+            constraints: token.constraints ? fillInGenerics(
+              token.constraints,
+              localGenerics,
+              preferLocalGenerics
+            ) : void 0,
+            default: token.default ? fillInGenerics(
+              token.default,
+              localGenerics,
+              preferLocalGenerics
+            ) : void 0
+          };
+        })
+      } : {},
+      extends: xlrNode.extends ? fillInGenerics(
+        xlrNode.extends,
+        localGenerics,
+        preferLocalGenerics
+      ) : void 0,
+      additionalProperties: xlrNode.additionalProperties ? fillInGenerics(
+        xlrNode.additionalProperties,
+        localGenerics,
+        preferLocalGenerics
+      ) : false
+    };
+  }
+  if (xlrNode.type === "array") {
+    return {
+      ...xlrNode,
+      elementType: fillInGenerics(
+        xlrNode.elementType,
+        localGenerics,
+        preferLocalGenerics
+      )
+    };
+  } else if (xlrNode.type === "or" || xlrNode.type === "and") {
+    let pointer;
+    if (xlrNode.type === "or") {
+      pointer = xlrNode.or;
+    } else {
+      pointer = xlrNode.and;
+    }
+    return {
+      ...xlrNode,
+      [xlrNode.type]: pointer.map((prop) => {
+        return fillInGenerics(prop, localGenerics, preferLocalGenerics);
+      })
+    };
+  } else if (xlrNode.type === "record") {
+    return {
+      ...xlrNode,
+      keyType: fillInGenerics(
+        xlrNode.keyType,
+        localGenerics,
+        preferLocalGenerics
+      ),
+      valueType: fillInGenerics(
+        xlrNode.valueType,
+        localGenerics,
+        preferLocalGenerics
+      )
+    };
+  } else if (xlrNode.type === "conditional") {
+    const filledInConditional = {
+      ...xlrNode,
+      check: {
+        left: fillInGenerics(
+          xlrNode.check.left,
+          localGenerics,
+          preferLocalGenerics
+        ),
+        right: fillInGenerics(
+          xlrNode.check.right,
+          localGenerics,
+          preferLocalGenerics
+        )
+      },
+      value: {
+        true: fillInGenerics(
+          xlrNode.value.true,
+          localGenerics,
+          preferLocalGenerics
+        ),
+        false: fillInGenerics(
+          xlrNode.value.false,
+          localGenerics,
+          preferLocalGenerics
+        )
+      }
+    };
+    if (filledInConditional.check.left.type !== "ref" && filledInConditional.check.right.type !== "ref") {
+      return {
+        name: xlrNode.name,
+        title: xlrNode.title,
+        ...resolveConditional(filledInConditional)
+      };
+    }
+    return filledInConditional;
+  }
+  return xlrNode;
+}
+function applyPickOrOmitToNodeType(baseObject, operation, properties) {
+  if (baseObject.type === "object") {
+    const newObject = { ...baseObject };
+    Object.keys(baseObject.properties).forEach((key) => {
+      if (operation === "Omit" && properties.has(key) || operation === "Pick" && !properties.has(key)) {
+        delete newObject.properties[key];
+      }
+    });
+    if (Object.keys(newObject.properties).length === 0 && (operation !== "Omit" || newObject.additionalProperties === false)) {
+      return void 0;
+    }
+    return newObject;
+  }
+  let pointer;
+  if (baseObject.type === "and") {
+    pointer = baseObject.and;
+  } else if (baseObject.type === "or") {
+    pointer = baseObject.or;
+  } else {
+    throw new Error(
+      `Error: Can not apply ${operation} to type ${baseObject.type}`
+    );
+  }
+  const pickedTypes = pointer.map((type) => {
+    const node = applyPickOrOmitToNodeType(type, operation, properties);
+    if (node === void 0) {
+      return void 0;
+    }
+    return { ...node, additionalProperties: false };
+  }).filter((type) => type !== void 0);
+  if (pickedTypes.length === 0) {
+    return void 0;
+  }
+  if (pickedTypes.length === 1) {
+    return pickedTypes[0];
+  }
+  if (baseObject.type === "and") {
+    return { ...baseObject, and: pickedTypes };
+  }
+  return { ...baseObject, or: pickedTypes };
+}
+function applyPartialOrRequiredToNodeType(baseObject, modifier) {
+  if (baseObject.type === "object") {
+    const newObject = { ...baseObject };
+    Object.keys(baseObject.properties).forEach((key) => {
+      newObject.properties[key].required = modifier;
+    });
+    return newObject;
+  }
+  if (baseObject.type === "and") {
+    const pickedTypes = baseObject.and.map(
+      (type) => applyPartialOrRequiredToNodeType(type, modifier)
+    );
+    return { ...baseObject, and: pickedTypes };
+  }
+  if (baseObject.type === "or") {
+    const pickedTypes = baseObject.or.map(
+      (type) => applyPartialOrRequiredToNodeType(type, modifier)
+    );
+    return { ...baseObject, or: pickedTypes };
+  }
+  throw new Error(
+    `Error: Can not apply ${modifier ? "Required" : "Partial"} to type ${baseObject.type}`
+  );
+}
+function applyExcludeToNodeType(baseObject, filters) {
+  const remainingMembers = baseObject.or.filter((type) => {
+    if (filters.type === "or") {
+      return !filters.or.some((filter) => computeExtends(type, filter));
+    }
+    return !computeExtends(type, filters);
+  });
+  if (remainingMembers.length === 1) {
+    return remainingMembers[0];
+  }
+  return {
+    ...baseObject,
+    or: remainingMembers
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyExcludeToNodeType,
+  applyPartialOrRequiredToNodeType,
+  applyPickOrOmitToNodeType,
+  computeEffectiveObject,
+  computeExtends,
+  fillInGenerics,
+  isAndType,
+  isArrayType,
+  isBooleanType,
+  isGenericNamedType,
+  isGenericNodeType,
+  isNamedType,
+  isNode,
+  isNonNullable,
+  isNumberType,
+  isObjectType,
+  isOrType,
+  isPrimitiveTypeNode,
+  isRecordType,
+  isRefType,
+  isStringType,
+  makePropertyMap,
+  propertyToTuple,
+  resolveConditional,
+  resolveReferenceNode
+});
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/utils/src/index.ts","../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/utils/src/type-checks.ts","../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/utils/src/validation-helpers.ts","../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/utils/src/xlr-helpers.ts"],"sourcesContent":["export * from \"./xlr-helpers\";\nexport * from \"./type-checks\";\nexport * from \"./validation-helpers\";\n","import type {\n  NamedType,\n  NamedTypeWithGenerics,\n  NodeType,\n  NodeTypeWithGenerics,\n  PrimitiveTypes,\n  StringType,\n  NumberType,\n  BooleanType,\n  ObjectType,\n  ArrayType,\n  RefType,\n  OrType,\n  AndType,\n  RecordType,\n} from \"@xlr-lib/xlr\";\n\n/**\n * Returns if the NodeType has generic tokens\n */\nexport function isGenericNodeType<T extends NodeType = NodeType>(\n  nt: NodeType,\n): nt is NodeTypeWithGenerics<T> {\n  return (nt as NodeTypeWithGenerics).genericTokens?.length > 0;\n}\n\n/**\n * Returns if the named type has generic tokens\n */\nexport function isGenericNamedType<T extends NamedType = NamedType>(\n  nt: NodeType,\n): nt is NamedTypeWithGenerics<T> {\n  return (nt as NamedTypeWithGenerics).genericTokens?.length > 0;\n}\n\n/**\n * Returns if the node is a `PrimitiveTypes`\n */\nexport function isPrimitiveTypeNode(node: NodeType): node is PrimitiveTypes {\n  return (\n    node.type === \"string\" ||\n    node.type === \"number\" ||\n    node.type === \"boolean\" ||\n    node.type === \"null\" ||\n    node.type === \"any\" ||\n    node.type === \"never\" ||\n    node.type === \"undefined\" ||\n    node.type === \"unknown\" ||\n    node.type === \"void\"\n  );\n}\n\n/**\n * Type Guard for non-null values\n */\nexport function isNonNullable<T>(a: T | null | undefined): a is NonNullable<T> {\n  return a !== null || a !== undefined;\n}\n\n/**\n * Type guard for string type nodes\n */\nexport function isStringType(node: NodeType): node is StringType {\n  return node.type === \"string\";\n}\n\n/**\n * Type guard for number type nodes\n */\nexport function isNumberType(node: NodeType): node is NumberType {\n  return node.type === \"number\";\n}\n\n/**\n * Type guard for boolean type nodes\n */\nexport function isBooleanType(node: NodeType): node is BooleanType {\n  return node.type === \"boolean\";\n}\n\n/**\n * Type guard for object type nodes\n */\nexport function isObjectType(node: NodeType): node is ObjectType {\n  return node.type === \"object\";\n}\n\n/**\n * Type guard for array type nodes\n */\nexport function isArrayType(node: NodeType): node is ArrayType {\n  return node.type === \"array\";\n}\n\n/**\n * Type guard for ref type nodes\n */\nexport function isRefType(node: NodeType): node is RefType {\n  return node.type === \"ref\";\n}\n\n/**\n * Type guard for or (union) type nodes\n */\nexport function isOrType(node: NodeType): node is OrType {\n  return node.type === \"or\";\n}\n\n/**\n * Type guard for and (intersection) type nodes\n */\nexport function isAndType(node: NodeType): node is AndType {\n  return node.type === \"and\";\n}\n\n/**\n * Type guard for record type nodes\n */\nexport function isRecordType(node: NodeType): node is RecordType {\n  return node.type === \"record\";\n}\n\n/**\n * Type guard for named types (have name and source)\n */\nexport function isNamedType<T extends NodeType = NodeType>(\n  node: NodeType,\n): node is NamedType<T> {\n  return \"name\" in node && \"source\" in node && typeof node.name === \"string\";\n}\n","import type { Node } from \"jsonc-parser\";\nimport type {\n  ConditionalType,\n  NodeType,\n  ObjectType,\n  RefNode,\n} from \"@xlr-lib/xlr\";\nimport { isGenericNodeType, isPrimitiveTypeNode } from \"./type-checks\";\nimport { fillInGenerics } from \"./xlr-helpers\";\n\nexport interface PropertyNode {\n  /** Equivalent Property Name */\n  key: string;\n\n  /** Equivalent Property Value */\n  value: Node;\n}\n\n/**\n * Takes a property node and returns the underlying Key/Value Pairs\n */\nexport function propertyToTuple(node: Node): PropertyNode {\n  return {\n    key: node.children?.[0].value as string,\n    value: node.children?.[1] as Node,\n  };\n}\n\n/**\n * Turns a node's children into a map for easy access\n */\nexport function makePropertyMap(node: Node): Map<string, Node> {\n  const m = new Map();\n  node.children?.forEach((child) => {\n    const property = propertyToTuple(child);\n    m.set(property.key, property.value);\n  });\n  return m;\n}\n\n/**\n * Checks if property is a leaf node or another node\n */\nexport function isNode(obj: Node | string | number | boolean): obj is Node {\n  return (\n    typeof obj !== \"string\" ||\n    typeof obj !== \"number\" ||\n    typeof obj !== \"boolean\"\n  );\n}\n\n/**\n * Computes if the first arg extends the second arg\n */\nexport function computeExtends(a: NodeType, b: NodeType): boolean {\n  // special case for any/unknown being functionally the same\n  if (\n    (a.type === \"any\" || a.type === \"unknown\") &&\n    (b.type === \"any\" || b.type === \"unknown\")\n  ) {\n    return true;\n  }\n\n  // special case for null/undefined being functionally the same\n  if (\n    (a.type === \"null\" || a.type === \"undefined\") &&\n    (b.type === \"null\" || b.type === \"undefined\")\n  ) {\n    return true;\n  }\n\n  // check simple case of equal types\n  if (a.type === b.type) {\n    if (isPrimitiveTypeNode(a) && isPrimitiveTypeNode(b)) {\n      if (a.const && b.const) {\n        if (a.const === b.const) {\n          return true;\n        }\n      } else {\n        return true;\n      }\n    }\n\n    if (a.type === \"ref\" && b.type === \"ref\") {\n      return a.ref === b.ref;\n    }\n\n    if (a.type === \"object\" && b.type === \"object\") {\n      for (const property in b.properties) {\n        const propertyNode = b.properties[property];\n        if (\n          !a.properties[property] ||\n          !computeExtends(a.properties[property].node, propertyNode.node)\n        ) {\n          return false;\n        }\n      }\n\n      return true;\n    }\n  }\n\n  if (isPrimitiveTypeNode(a) && b.type === \"or\") {\n    return b.or.every((member) => computeExtends(a, member));\n  }\n\n  if (isPrimitiveTypeNode(b) && a.type === \"or\") {\n    return a.or.every((member) => computeExtends(b, member));\n  }\n\n  if (a.type === \"or\" && b.type === \"or\") {\n    return a.or.every((x) => b.or.some((y) => computeExtends(x, y)));\n  }\n\n  return false;\n}\n\n/**\n * Attempts to resolve a conditional type\n */\nexport function resolveConditional(conditional: ConditionalType): NodeType {\n  const { left, right } = conditional.check;\n  const conditionalResult = computeExtends(left, right)\n    ? conditional.value.true\n    : conditional.value.false;\n\n  // Compose first level generics here since `conditionalResult` won't have them\n  if (isGenericNodeType(conditional)) {\n    const genericMap: Map<string, NodeType> = new Map();\n    conditional.genericTokens.forEach((token) => {\n      genericMap.set(\n        token.symbol,\n        token.default ?? token.constraints ?? { type: \"any\" },\n      );\n    });\n\n    return fillInGenerics(conditionalResult, genericMap);\n  }\n\n  return conditionalResult;\n}\n\n/**\n * Resolve referenced node with potential generic arguments\n */\nexport function resolveReferenceNode(\n  genericReference: RefNode,\n  typeToFill: NodeType,\n): NodeType {\n  const genericArgs = genericReference.genericArguments;\n  const genericMap: Map<string, NodeType> = new Map();\n\n  // Compose first level generics here from `genericReference`\n  if (genericArgs && isGenericNodeType(typeToFill)) {\n    typeToFill.genericTokens.forEach((token, index) => {\n      genericMap.set(\n        token.symbol,\n        genericArgs[index] ?? token.default ?? token.constraints,\n      );\n    });\n  }\n\n  // Fill in generics\n  const filledInNode = fillInGenerics(typeToFill, genericMap);\n\n  // Remove generic tokens that were resolve\n  if (isGenericNodeType(filledInNode) && genericArgs?.length) {\n    if (genericArgs.length < filledInNode.genericTokens.length) {\n      filledInNode.genericTokens = filledInNode.genericTokens.slice(\n        genericArgs?.length,\n      );\n    } else if (genericArgs.length === filledInNode.genericTokens.length) {\n      filledInNode.genericTokens = [];\n    }\n  }\n\n  // Resolve index access\n  if (genericReference.property && filledInNode.type === \"object\") {\n    return (\n      filledInNode.properties[genericReference.property]?.node ??\n      filledInNode.additionalProperties ?? { type: \"undefined\" }\n    );\n  }\n\n  return filledInNode;\n}\n\n/**\n * Combines two ObjectType objects to get a representation of the effective TypeScript interface of `base` extending `operand`\n - * @param base The base interface\n - * @param operand The interface that is extended\n - * @param errorOnOverlap whether or not conflicting properties should throw an error or use the property from operand\n - * @returns `ObjectType`\n */\nexport function computeEffectiveObject(\n  base: ObjectType,\n  operand: ObjectType,\n  errorOnOverlap = true,\n): ObjectType {\n  const baseObjectName = base.name ?? base.title ?? \"object literal\";\n  const operandObjectName = operand.name ?? operand.title ?? \"object literal\";\n  const newObject = {\n    ...JSON.parse(JSON.stringify(base)),\n    name: `${baseObjectName} & ${operandObjectName}`,\n    description: `Effective type combining ${baseObjectName} and ${operandObjectName}`,\n    genericTokens: [\n      ...(isGenericNodeType(base) ? base.genericTokens : []),\n      ...(isGenericNodeType(operand) ? operand.genericTokens : []),\n    ],\n  };\n  // TODO this check needs to account for primitive -> primitive generic overlap\n\n  for (const property in operand.properties) {\n    if (newObject.properties[property] !== undefined && errorOnOverlap) {\n      if (\n        !computeExtends(\n          newObject.properties[property].node,\n          operand.properties[property].node,\n        )\n      ) {\n        throw new Error(\n          `Can't compute effective type for ${baseObjectName} and ${operandObjectName} because of conflicting properties ${property}`,\n        );\n      }\n    }\n\n    newObject.properties[property] = operand.properties[property];\n  }\n\n  if (newObject.additionalProperties && operand.additionalProperties) {\n    if (\n      !isPrimitiveTypeNode(newObject.additionalProperties) ||\n      !isPrimitiveTypeNode(operand.additionalProperties) ||\n      newObject.additionalProperties.type !== operand.additionalProperties.type\n    ) {\n      newObject.additionalProperties = {\n        type: \"and\",\n        and: [newObject.additionalProperties, operand.additionalProperties],\n      };\n    }\n  } else if (operand.additionalProperties) {\n    newObject.additionalProperties = operand.additionalProperties;\n  }\n\n  return newObject;\n}\n","import type {\n  NamedType,\n  NodeType,\n  ObjectProperty,\n  ObjectType,\n  OrType,\n  RefNode,\n} from \"@xlr-lib/xlr\";\nimport { computeExtends, resolveConditional } from \"./validation-helpers\";\nimport { isGenericNamedType, isGenericNodeType } from \"./type-checks\";\n\n/**\n * Walks generics to fill in values from a combination of the default, constraint, and passed in map values\n * TODO convert this to use simpleTransformGenerator\n */\nexport function fillInGenerics(\n  xlrNode: NodeType,\n  generics?: Map<string, NodeType>,\n  preferLocalGenerics = false,\n): NodeType {\n  // Need to make sure not to set generics in passed in map to avoid using generics outside of tree\n  let localGenerics: Map<string, NodeType>;\n\n  if (generics) {\n    localGenerics = new Map(generics);\n    if (preferLocalGenerics && isGenericNodeType(xlrNode)) {\n      xlrNode.genericTokens?.forEach((token) => {\n        const genericValue = (token.default ?? token.constraints) as NodeType;\n        localGenerics.set(\n          token.symbol,\n          fillInGenerics(genericValue, localGenerics, preferLocalGenerics),\n        );\n      });\n    }\n  } else {\n    localGenerics = new Map();\n    if (isGenericNodeType(xlrNode)) {\n      xlrNode.genericTokens?.forEach((token) => {\n        const genericValue = (token.default ?? token.constraints) as NodeType;\n        localGenerics.set(\n          token.symbol,\n          fillInGenerics(genericValue, localGenerics, preferLocalGenerics),\n        );\n      });\n    }\n  }\n\n  if (xlrNode.type === \"ref\") {\n    if (localGenerics.has(xlrNode.ref)) {\n      return {\n        ...(localGenerics.get(xlrNode.ref) as NodeType),\n        ...(xlrNode.genericArguments\n          ? {\n              genericArguments: xlrNode.genericArguments.map((ga) =>\n                fillInGenerics(ga, localGenerics, preferLocalGenerics),\n              ),\n            }\n          : {}),\n        ...(xlrNode.title ? { title: xlrNode.title } : {}),\n        ...(xlrNode.name ? { name: xlrNode.name } : {}),\n        ...(xlrNode.description ? { description: xlrNode.description } : {}),\n        ...(xlrNode.comment ? { comment: xlrNode.comment } : {}),\n      };\n    }\n\n    return {\n      ...xlrNode,\n      ...(xlrNode.genericArguments\n        ? {\n            genericArguments: xlrNode.genericArguments.map((ga) =>\n              fillInGenerics(ga, localGenerics, preferLocalGenerics),\n            ),\n          }\n        : {}),\n    };\n  }\n\n  if (xlrNode.type === \"object\") {\n    const newProperties: { [name: string]: ObjectProperty } = {};\n    Object.getOwnPropertyNames(xlrNode.properties).forEach((propName) => {\n      const prop = xlrNode.properties[propName];\n      newProperties[propName] = {\n        required: prop.required,\n        node: fillInGenerics(prop.node, localGenerics, preferLocalGenerics),\n      };\n    });\n\n    return {\n      ...xlrNode,\n      properties: newProperties,\n      ...(isGenericNamedType(xlrNode)\n        ? {\n            genericTokens: xlrNode.genericTokens.map((token) => {\n              return {\n                ...token,\n                constraints: token.constraints\n                  ? fillInGenerics(\n                      token.constraints,\n                      localGenerics,\n                      preferLocalGenerics,\n                    )\n                  : undefined,\n                default: token.default\n                  ? fillInGenerics(\n                      token.default,\n                      localGenerics,\n                      preferLocalGenerics,\n                    )\n                  : undefined,\n              };\n            }),\n          }\n        : {}),\n      extends: xlrNode.extends\n        ? (fillInGenerics(\n            xlrNode.extends,\n            localGenerics,\n            preferLocalGenerics,\n          ) as RefNode)\n        : undefined,\n      additionalProperties: xlrNode.additionalProperties\n        ? fillInGenerics(\n            xlrNode.additionalProperties,\n            localGenerics,\n            preferLocalGenerics,\n          )\n        : false,\n    };\n  }\n\n  if (xlrNode.type === \"array\") {\n    return {\n      ...xlrNode,\n      elementType: fillInGenerics(\n        xlrNode.elementType,\n        localGenerics,\n        preferLocalGenerics,\n      ),\n    };\n  } else if (xlrNode.type === \"or\" || xlrNode.type === \"and\") {\n    let pointer;\n    if (xlrNode.type === \"or\") {\n      pointer = xlrNode.or;\n    } else {\n      pointer = xlrNode.and;\n    }\n\n    return {\n      ...xlrNode,\n      [xlrNode.type]: pointer.map((prop) => {\n        return fillInGenerics(prop, localGenerics, preferLocalGenerics);\n      }),\n    };\n  } else if (xlrNode.type === \"record\") {\n    return {\n      ...xlrNode,\n      keyType: fillInGenerics(\n        xlrNode.keyType,\n        localGenerics,\n        preferLocalGenerics,\n      ),\n      valueType: fillInGenerics(\n        xlrNode.valueType,\n        localGenerics,\n        preferLocalGenerics,\n      ),\n    };\n  } else if (xlrNode.type === \"conditional\") {\n    const filledInConditional = {\n      ...xlrNode,\n      check: {\n        left: fillInGenerics(\n          xlrNode.check.left,\n          localGenerics,\n          preferLocalGenerics,\n        ),\n        right: fillInGenerics(\n          xlrNode.check.right,\n          localGenerics,\n          preferLocalGenerics,\n        ),\n      },\n      value: {\n        true: fillInGenerics(\n          xlrNode.value.true,\n          localGenerics,\n          preferLocalGenerics,\n        ),\n        false: fillInGenerics(\n          xlrNode.value.false,\n          localGenerics,\n          preferLocalGenerics,\n        ),\n      },\n    };\n\n    // Check to see if we have enough information to resolve this conditional\n    if (\n      filledInConditional.check.left.type !== \"ref\" &&\n      filledInConditional.check.right.type !== \"ref\"\n    ) {\n      return {\n        name: xlrNode.name,\n        title: xlrNode.title,\n        ...resolveConditional(filledInConditional),\n      } as NamedType;\n    }\n\n    return filledInConditional;\n  }\n\n  return xlrNode;\n}\n\n/** Applies the TS `Pick` or `Omit` type to an interface/union/intersection */\nexport function applyPickOrOmitToNodeType(\n  baseObject: NodeType,\n  operation: \"Pick\" | \"Omit\",\n  properties: Set<string>,\n): NodeType | undefined {\n  if (baseObject.type === \"object\") {\n    const newObject = { ...baseObject };\n    Object.keys(baseObject.properties).forEach((key) => {\n      if (\n        (operation === \"Omit\" && properties.has(key)) ||\n        (operation === \"Pick\" && !properties.has(key))\n      ) {\n        delete newObject.properties[key];\n      }\n    });\n\n    /**\n     * Filter out objects in cases:\n     * - A Pick operation and there are no properties left\n     * - An Omit operation and there are no properties left and no additional properties allowed\n     */\n    if (\n      Object.keys(newObject.properties).length === 0 &&\n      (operation !== \"Omit\" || newObject.additionalProperties === false)\n    ) {\n      return undefined;\n    }\n\n    return newObject;\n  }\n\n  let pointer;\n  if (baseObject.type === \"and\") {\n    pointer = baseObject.and;\n  } else if (baseObject.type === \"or\") {\n    pointer = baseObject.or;\n  } else {\n    throw new Error(\n      `Error: Can not apply ${operation} to type ${baseObject.type}`,\n    );\n  }\n\n  const pickedTypes = pointer\n    .map((type) => {\n      const node = applyPickOrOmitToNodeType(type, operation, properties);\n      if (node === undefined) {\n        return undefined;\n      }\n\n      return { ...node, additionalProperties: false } as ObjectType;\n    })\n    .filter((type) => type !== undefined) as NodeType[];\n\n  if (pickedTypes.length === 0) {\n    return undefined;\n  }\n\n  if (pickedTypes.length === 1) {\n    return pickedTypes[0];\n  }\n\n  if (baseObject.type === \"and\") {\n    return { ...baseObject, and: pickedTypes };\n  }\n\n  return { ...baseObject, or: pickedTypes };\n}\n\n/** Applies the TS `Partial` or `Required` type to an interface/union/intersection */\nexport function applyPartialOrRequiredToNodeType(\n  baseObject: NodeType,\n  modifier: boolean,\n): NodeType {\n  if (baseObject.type === \"object\") {\n    const newObject = { ...baseObject };\n    Object.keys(baseObject.properties).forEach((key) => {\n      newObject.properties[key].required = modifier;\n    });\n\n    return newObject;\n  }\n\n  if (baseObject.type === \"and\") {\n    const pickedTypes = baseObject.and.map((type) =>\n      applyPartialOrRequiredToNodeType(type, modifier),\n    );\n    return { ...baseObject, and: pickedTypes };\n  }\n\n  if (baseObject.type === \"or\") {\n    const pickedTypes = baseObject.or.map((type) =>\n      applyPartialOrRequiredToNodeType(type, modifier),\n    );\n    return { ...baseObject, or: pickedTypes };\n  }\n\n  throw new Error(\n    `Error: Can not apply ${modifier ? \"Required\" : \"Partial\"} to type ${\n      baseObject.type\n    }`,\n  );\n}\n\n/** Applies the TS `Exclude` type to a union */\nexport function applyExcludeToNodeType(\n  baseObject: OrType,\n  filters: NodeType | OrType,\n): NodeType {\n  const remainingMembers = baseObject.or.filter((type) => {\n    if (filters.type === \"or\") {\n      return !filters.or.some((filter) => computeExtends(type, filter));\n    }\n\n    return !computeExtends(type, filters);\n  });\n\n  if (remainingMembers.length === 1) {\n    return remainingMembers[0];\n  }\n\n  return {\n    ...baseObject,\n    or: remainingMembers,\n  };\n}\n"],"mappings":"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","names":[]}