@xlr-lib/xlr-sdk 0.1.1-next.0

package/dist/index.legacy-esm.js

@@ -0,0 +1,961 @@
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/sdk/src/sdk.ts
+import {
+  computeEffectiveObject as computeEffectiveObject2,
+  resolveConditional as resolveConditional2,
+  resolveReferenceNode as resolveReferenceNode2
+} from "@xlr-lib/xlr-utils";
+import { fillInGenerics } from "@xlr-lib/xlr-utils";
+import { TSWriter } from "@xlr-lib/xlr-converters";
+import fs from "fs";
+import path from "path";
+import ts from "typescript";
+
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/sdk/src/registry/basic-registry.ts
+var BasicXLRRegistry = class {
+  typeMap;
+  pluginMap;
+  infoMap;
+  constructor() {
+    this.typeMap = /* @__PURE__ */ new Map();
+    this.pluginMap = /* @__PURE__ */ new Map();
+    this.infoMap = /* @__PURE__ */ new Map();
+  }
+  /** Returns a copy of the XLR to guard against unexpected type modification */
+  get(id) {
+    const value = this.typeMap.get(id);
+    return value ? JSON.parse(JSON.stringify(value)) : void 0;
+  }
+  add(type, plugin, capability) {
+    this.typeMap.set(type.name, type);
+    this.infoMap.set(type.name, { plugin, capability });
+    if (!this.pluginMap.has(plugin)) {
+      this.pluginMap.set(plugin, /* @__PURE__ */ new Map());
+    }
+    const pluginsCapabilities = this.pluginMap.get(plugin);
+    if (!pluginsCapabilities.has(capability)) {
+      pluginsCapabilities.set(capability, []);
+    }
+    const providedCapabilities = pluginsCapabilities.get(
+      capability
+    );
+    providedCapabilities.push(type.name);
+  }
+  has(id) {
+    return this.typeMap.has(id);
+  }
+  list(filterArgs) {
+    const validTypes = [];
+    this.pluginMap.forEach((manifest, pluginName) => {
+      if (!filterArgs?.pluginFilter || !pluginName.match(filterArgs.pluginFilter)) {
+        manifest.forEach((types, capabilityName) => {
+          if (!filterArgs?.capabilityFilter || !capabilityName.match(filterArgs.capabilityFilter)) {
+            types.forEach((type) => {
+              if (!filterArgs?.typeFilter || !type.match(filterArgs.typeFilter)) {
+                validTypes.push(type);
+              }
+            });
+          }
+        });
+      }
+    });
+    return validTypes.map((type) => this.get(type));
+  }
+  info(id) {
+    return this.infoMap.get(id);
+  }
+};
+
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/sdk/src/validator.ts
+import {
+  makePropertyMap,
+  resolveConditional,
+  isPrimitiveTypeNode,
+  resolveReferenceNode,
+  computeEffectiveObject
+} from "@xlr-lib/xlr-utils";
+
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/sdk/src/types.ts
+var ValidationSeverity = /* @__PURE__ */ ((ValidationSeverity2) => {
+  ValidationSeverity2[ValidationSeverity2["Error"] = 1] = "Error";
+  ValidationSeverity2[ValidationSeverity2["Warning"] = 2] = "Warning";
+  ValidationSeverity2[ValidationSeverity2["Info"] = 3] = "Info";
+  ValidationSeverity2[ValidationSeverity2["Trace"] = 4] = "Trace";
+  return ValidationSeverity2;
+})(ValidationSeverity || {});
+
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/sdk/src/validator.ts
+var MAX_VALID_SHOWN = 20;
+var XLRValidator = class {
+  config;
+  resolveType;
+  regexCache;
+  constructor(resolveType, config) {
+    this.config = config || {};
+    this.resolveType = resolveType;
+    this.regexCache = /* @__PURE__ */ new Map();
+  }
+  /** Main entrypoint for validation */
+  validateType(rootNode, xlrNode) {
+    const validationIssues = new Array();
+    if (xlrNode.type === "object") {
+      if (rootNode.type === "object") {
+        validationIssues.push(...this.validateObject(xlrNode, rootNode));
+      } else {
+        validationIssues.push({
+          type: "type",
+          node: rootNode,
+          message: `Expected an object but got an "${rootNode.type}"`,
+          severity: 1 /* Error */
+        });
+      }
+    } else if (xlrNode.type === "array") {
+      if (rootNode.type === "array") {
+        validationIssues.push(...this.validateArray(rootNode, xlrNode));
+      } else {
+        validationIssues.push({
+          type: "type",
+          node: rootNode,
+          message: `Expected an array but got an "${rootNode.type}"`,
+          severity: 1 /* Error */
+        });
+      }
+    } else if (xlrNode.type === "template") {
+      const error = this.validateTemplate(rootNode, xlrNode);
+      if (error) {
+        validationIssues.push(error);
+      }
+    } else if (xlrNode.type === "or") {
+      const potentialTypeErrors = [];
+      for (const potentialType of xlrNode.or) {
+        const potentialErrors = this.validateType(rootNode, potentialType);
+        if (potentialErrors.length === 0) {
+          return validationIssues;
+        }
+        potentialTypeErrors.push({
+          type: potentialType,
+          errors: potentialErrors
+        });
+      }
+      let message;
+      const expectedTypes = xlrNode.or.map(
+        (node) => isPrimitiveTypeNode(node) ? node.type : node.name ?? node.title ?? node.type ?? "<unnamed type>"
+      ).join(" | ");
+      if (xlrNode.name) {
+        message = `Does not match any of the expected types for type: '${xlrNode.name}'`;
+      } else if (xlrNode.title) {
+        message = `Does not match any of the expected types for property: '${xlrNode.title}'`;
+      } else {
+        message = `Does not match any of the types: ${expectedTypes}`;
+      }
+      const { infoMessage } = this.generateNestedTypesInfo(
+        potentialTypeErrors,
+        xlrNode,
+        rootNode
+      );
+      validationIssues.push({
+        type: "value",
+        node: rootNode,
+        message: message.trim(),
+        severity: 1 /* Error */
+      });
+      if (infoMessage) {
+        validationIssues.push({
+          type: "value",
+          node: rootNode,
+          message: infoMessage,
+          severity: 3 /* Info */
+        });
+      }
+    } else if (xlrNode.type === "and") {
+      const effectiveType = {
+        ...this.computeIntersectionType(xlrNode.and),
+        ...xlrNode.name ? { name: xlrNode.name } : {}
+      };
+      validationIssues.push(...this.validateType(rootNode, effectiveType));
+    } else if (xlrNode.type === "record") {
+      rootNode.children?.forEach((child) => {
+        validationIssues.push(
+          ...this.validateType(child.children?.[0], xlrNode.keyType)
+        );
+        validationIssues.push(
+          ...this.validateType(child.children?.[1], xlrNode.valueType)
+        );
+      });
+    } else if (xlrNode.type === "ref") {
+      const refType = this.getRefType(xlrNode);
+      if (refType === void 0) {
+        validationIssues.push({
+          type: "unknown",
+          node: rootNode,
+          message: `Type "${xlrNode.ref}" is not defined in provided bundles`,
+          severity: 1 /* Error */
+        });
+      } else {
+        validationIssues.push(
+          ...this.validateType(rootNode, refType)
+        );
+      }
+    } else if (isPrimitiveTypeNode(xlrNode)) {
+      if (!this.validateLiteralType(xlrNode, rootNode)) {
+        if ((xlrNode.type === "string" || xlrNode.type === "number" || xlrNode.type === "boolean") && xlrNode.const) {
+          validationIssues.push({
+            type: "type",
+            node: rootNode.parent,
+            message: `Expected "${xlrNode.const}" but got "${rootNode.value}"`,
+            expected: xlrNode.const,
+            severity: 1 /* Error */
+          });
+        } else {
+          validationIssues.push({
+            type: "type",
+            node: rootNode.parent,
+            message: `Expected type "${xlrNode.type}" but got "${rootNode.type}"`,
+            expected: xlrNode.type,
+            severity: 1 /* Error */
+          });
+        }
+      }
+    } else if (xlrNode.type === "conditional") {
+      let { right, left } = xlrNode.check;
+      if (right.type === "ref") {
+        right = this.getRefType(right);
+      }
+      if (left.type === "ref") {
+        left = this.getRefType(left);
+      }
+      const resolvedXLRNode = {
+        ...xlrNode,
+        check: {
+          left,
+          right
+        }
+      };
+      const resolvedConditional = resolveConditional(resolvedXLRNode);
+      if (resolvedConditional === resolvedXLRNode) {
+        throw Error(
+          `Unable to resolve conditional type at runtime: ${xlrNode.name}`
+        );
+      }
+      validationIssues.push(
+        ...this.validateType(rootNode, resolvedConditional)
+      );
+    } else {
+      throw Error(`Unknown type ${xlrNode.type}`);
+    }
+    return validationIssues;
+  }
+  generateNestedTypesInfo(potentialTypeErrors, xlrNode, rootNode) {
+    const nestedTypes = /* @__PURE__ */ new Set();
+    potentialTypeErrors.forEach((typeError) => {
+      if (typeError.type.type !== "template") {
+        typeError.errors.forEach((error) => {
+          if (error.type === "type" && error.expected) {
+            String(error.expected).split(" | ").forEach((val) => nestedTypes.add(val.trim()));
+          }
+        });
+      }
+    });
+    if (nestedTypes.size === 0) {
+      xlrNode.or.forEach((type) => {
+        const typeName = type.name ?? type.title ?? type.type ?? "<unnamed type>";
+        nestedTypes.add(typeName);
+      });
+    }
+    const nestedTypesArray = [...nestedTypes];
+    let nestedTypesList = nestedTypesArray.slice(0, MAX_VALID_SHOWN).join(" | ") + (nestedTypesArray.length > MAX_VALID_SHOWN ? ` | +${nestedTypesArray.length - MAX_VALID_SHOWN} ... ${nestedTypesArray.pop()}` : "");
+    const docsURL = this.config.urlMapping;
+    if (docsURL && xlrNode.name && docsURL[xlrNode.name]) {
+      nestedTypesList = docsURL[xlrNode.name];
+    }
+    let infoMessage;
+    if (rootNode.value !== void 0) {
+      infoMessage = `Got: ${rootNode.value} and expected: ${nestedTypesList}`;
+    } else if (nestedTypesList) {
+      infoMessage = `Expected: ${nestedTypesList}`;
+    }
+    return { nestedTypesList, infoMessage };
+  }
+  validateTemplate(node, xlrNode) {
+    if (node.type !== "string") {
+      return {
+        type: "type",
+        node: node.parent,
+        message: `Expected type "${xlrNode.type}" but got "${typeof node}"`,
+        expected: xlrNode.type,
+        severity: 1 /* Error */
+      };
+    }
+    const regex = this.getRegex(xlrNode.format);
+    const valid = regex.exec(node.value);
+    if (!valid) {
+      return {
+        type: "value",
+        node: node.parent,
+        message: `Does not match expected format: ${xlrNode.format}`,
+        expected: xlrNode.format,
+        severity: 1 /* Error */
+      };
+    }
+  }
+  validateArray(rootNode, xlrNode) {
+    const issues = [];
+    rootNode.children?.forEach(
+      (child) => issues.push(...this.validateType(child, xlrNode.elementType))
+    );
+    return issues;
+  }
+  validateObject(xlrNode, node) {
+    const issues = [];
+    const objectProps = makePropertyMap(node);
+    for (const prop in xlrNode.properties) {
+      const expectedType = xlrNode.properties[prop];
+      const valueNode = objectProps.get(prop);
+      if (expectedType.required && valueNode === void 0) {
+        issues.push({
+          type: "missing",
+          node,
+          message: `Property "${prop}" missing from type "${xlrNode.name}"`,
+          severity: 1 /* Error */
+        });
+      }
+      if (valueNode) {
+        issues.push(
+          ...this.validateType(valueNode, expectedType.node)
+        );
+      }
+    }
+    const extraKeys = Array.from(objectProps.keys()).filter(
+      (key) => xlrNode.properties[key] === void 0
+    );
+    if (xlrNode.additionalProperties === false && extraKeys.length > 0) {
+      issues.push({
+        type: "value",
+        node,
+        message: `Unexpected properties on "${xlrNode.name}": ${extraKeys.join(
+          ", "
+        )}`,
+        severity: 1 /* Error */
+      });
+    } else {
+      issues.push(
+        ...extraKeys.flatMap(
+          (key) => this.validateType(
+            objectProps.get(key),
+            xlrNode.additionalProperties
+          )
+        )
+      );
+    }
+    return issues;
+  }
+  validateLiteralType(expectedType, literalType) {
+    switch (expectedType.type) {
+      case "boolean":
+        if (expectedType.const) {
+          return expectedType.const === literalType.value;
+        }
+        return typeof literalType.value === "boolean";
+      case "number":
+        if (expectedType.const) {
+          return expectedType.const === literalType.value;
+        }
+        return typeof literalType.value === "number";
+      case "string":
+        if (expectedType.const) {
+          return expectedType.const === literalType.value;
+        }
+        return typeof literalType.value === "string";
+      case "null":
+        return literalType.value === null;
+      case "never":
+        return literalType === void 0;
+      case "any":
+        return literalType !== void 0;
+      case "unknown":
+        return literalType !== void 0;
+      case "undefined":
+        return true;
+      default:
+        return false;
+    }
+  }
+  getRefType(ref) {
+    let refName = ref.ref;
+    if (refName.indexOf("<") > 0) {
+      [refName] = refName.split("<");
+    }
+    const actualType = this.resolveType(refName);
+    if (!actualType) {
+      throw new Error(`Error: can't resolve type reference ${refName}`);
+    }
+    return resolveReferenceNode(ref, actualType);
+  }
+  getRegex(expString) {
+    if (this.regexCache.has(expString)) {
+      return this.regexCache.get(expString);
+    }
+    const exp = new RegExp(expString);
+    this.regexCache.set(expString, exp);
+    return exp;
+  }
+  computeIntersectionType(types) {
+    let firstElement = types[0];
+    let effectiveType;
+    const topLevelTypeName = types[0].name;
+    if (firstElement.type === "ref") {
+      firstElement = this.getRefType(firstElement);
+    }
+    if (firstElement.type === "and") {
+      effectiveType = this.computeIntersectionType(firstElement.and);
+    } else if (firstElement.type === "record") {
+      effectiveType = {
+        type: "object",
+        properties: {},
+        additionalProperties: firstElement.valueType
+      };
+    } else if (firstElement.type !== "or" && firstElement.type !== "object") {
+      throw new Error(
+        `Can't compute a union with a non-object type ${firstElement.type} (${firstElement.name})`
+      );
+    } else {
+      effectiveType = firstElement;
+    }
+    types.slice(1).forEach((type) => {
+      let typeToApply = type;
+      if (typeToApply.type === "record") {
+        typeToApply = {
+          type: "object",
+          properties: {},
+          additionalProperties: typeToApply.valueType
+        };
+      }
+      if (type.type === "ref") {
+        typeToApply = this.getRefType(type);
+      }
+      if (typeToApply.type === "and") {
+        typeToApply = this.computeIntersectionType([type, effectiveType]);
+      }
+      if (typeToApply.type === "object") {
+        if (effectiveType.type === "object") {
+          effectiveType = computeEffectiveObject(effectiveType, typeToApply);
+        } else {
+          effectiveType = {
+            ...effectiveType,
+            or: effectiveType.or.map((y) => {
+              const intersectedType = this.computeIntersectionType([
+                y,
+                typeToApply
+              ]);
+              if (!intersectedType.name && topLevelTypeName) {
+                intersectedType.name = topLevelTypeName;
+              }
+              return intersectedType;
+            })
+          };
+        }
+      } else if (typeToApply.type === "or") {
+        if (effectiveType.type === "object") {
+          effectiveType = {
+            ...typeToApply,
+            or: typeToApply.or.map((y) => {
+              const intersectedType = this.computeIntersectionType([
+                y,
+                effectiveType
+              ]);
+              if (!intersectedType.name && topLevelTypeName) {
+                intersectedType.name = topLevelTypeName;
+              }
+              return intersectedType;
+            })
+          };
+        } else {
+          throw new Error("unimplemented operation or x or projection");
+        }
+      } else {
+        throw new Error(
+          `Can't compute a union with a non-object type ${typeToApply.type} (${typeToApply.name})`
+        );
+      }
+    });
+    if (effectiveType.type === "or" && !effectiveType.name && topLevelTypeName) {
+      effectiveType.name = topLevelTypeName;
+    }
+    return effectiveType;
+  }
+};
+
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/sdk/src/utils.ts
+import { isGenericNamedType } from "@xlr-lib/xlr-utils";
+var isMatchingCapability = (capability, capabilitiesToMatch) => {
+  if (Array.isArray(capabilitiesToMatch)) {
+    return capabilitiesToMatch.includes(capability);
+  }
+  return capability === capabilitiesToMatch;
+};
+function xlrTransformWalker(transformMap) {
+  const walker = (n) => {
+    let node = { ...n };
+    const transformFunctions = transformMap[node.type];
+    for (const transformFn of transformFunctions ?? []) {
+      node = transformFn(node);
+    }
+    if (node.type === "object") {
+      const newObjectProperties = {};
+      for (const key in node.properties) {
+        const value = node.properties[key];
+        newObjectProperties[key] = {
+          required: value.required,
+          node: walker(value.node)
+        };
+      }
+      return {
+        ...node,
+        properties: { ...newObjectProperties },
+        ...isGenericNamedType(node) ? {
+          genericTokens: node.genericTokens.map((token) => {
+            return {
+              ...token,
+              constraints: token.constraints ? walker(token.constraints) : void 0,
+              default: token.default ? walker(token.default) : void 0
+            };
+          })
+        } : {},
+        extends: node.extends ? walker(node.extends) : void 0,
+        additionalProperties: node.additionalProperties ? walker(node.additionalProperties) : false
+      };
+    }
+    if (node.type === "array") {
+      return {
+        ...node,
+        elementType: walker(node.elementType)
+      };
+    }
+    if (node.type === "and") {
+      return {
+        ...node,
+        and: node.and.map((element) => walker(element))
+      };
+    }
+    if (node.type === "or") {
+      return {
+        ...node,
+        or: node.or.map((element) => walker(element))
+      };
+    }
+    if (node.type === "ref") {
+      return {
+        ...node,
+        ...node.genericArguments ? {
+          genericArguments: node.genericArguments?.map(
+            (arg) => walker(arg)
+          )
+        } : {}
+      };
+    }
+    if (node.type === "tuple") {
+      return {
+        ...node,
+        elementTypes: node.elementTypes.map((element) => {
+          return {
+            name: element.name,
+            type: walker(element.type),
+            optional: element.optional
+          };
+        }),
+        additionalItems: node.additionalItems ? walker(node.additionalItems) : false
+      };
+    }
+    if (node.type === "function") {
+      return {
+        ...node,
+        parameters: node.parameters.map((param) => {
+          return {
+            ...param,
+            type: walker(param.type),
+            default: param.default ? walker(param.default) : void 0
+          };
+        }),
+        returnType: node.returnType ? walker(node.returnType) : void 0
+      };
+    }
+    if (node.type === "record") {
+      return {
+        ...node,
+        keyType: walker(node.keyType),
+        valueType: walker(node.valueType)
+      };
+    }
+    if (node.type === "conditional") {
+      return {
+        ...node,
+        check: {
+          left: walker(node.check.left),
+          right: walker(node.check.left)
+        },
+        value: {
+          true: walker(node.value.true),
+          false: walker(node.value.false)
+        }
+      };
+    }
+    return node;
+  };
+  return walker;
+}
+function simpleTransformGenerator(typeToTransform, capabilityToTransform, functionToRun) {
+  return (n, capability) => {
+    if (isMatchingCapability(capability, capabilityToTransform)) {
+      return xlrTransformWalker({ [typeToTransform]: [functionToRun] })(n);
+    }
+    return n;
+  };
+}
+
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/sdk/src/sdk.ts
+var XLRSDK = class {
+  registry;
+  validator;
+  tsWriter;
+  computedNodeCache;
+  externalTransformFunctions;
+  constructor(customRegistry) {
+    this.registry = customRegistry ?? new BasicXLRRegistry();
+    this.validator = new XLRValidator(this.getType.bind(this));
+    this.tsWriter = new TSWriter();
+    this.computedNodeCache = /* @__PURE__ */ new Map();
+    this.externalTransformFunctions = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Loads definitions from a path on the filesystem
+   *
+   * @param inputPath - path to the directory to load (above the xlr folder)
+   * @param filters - Any filters to apply when loading the types (a positive match will omit)
+   * @param transforms - any transforms to apply to the types being loaded
+   */
+  loadDefinitionsFromDisk(inputPath, filters, transforms) {
+    this.computedNodeCache.clear();
+    const transformsToRun = [
+      ...this.externalTransformFunctions.values(),
+      ...transforms ?? []
+    ];
+    const manifest = JSON.parse(
+      fs.readFileSync(path.join(inputPath, "xlr", "manifest.json")).toString(),
+      (key, value) => {
+        if (typeof value === "object" && value !== null) {
+          if (key === "capabilities") {
+            return new Map(Object.entries(value));
+          }
+        }
+        return value;
+      }
+    );
+    manifest.capabilities?.forEach((capabilityList, capabilityName) => {
+      if (filters?.capabilityFilter && capabilityName.match(filters?.capabilityFilter))
+        return;
+      capabilityList.forEach((extensionName) => {
+        if (!filters?.typeFilter || !extensionName.match(filters?.typeFilter)) {
+          const cType = JSON.parse(
+            fs.readFileSync(
+              path.join(inputPath, "xlr", `${extensionName}.json`)
+            ).toString()
+          );
+          const effectiveType = transformsToRun?.reduce(
+            (typeAccumulator, transformFn) => transformFn(
+              typeAccumulator,
+              capabilityName
+            ),
+            cType
+          ) ?? cType;
+          this.registry.add(effectiveType, manifest.pluginName, capabilityName);
+        }
+      });
+    });
+  }
+  /**
+   * Load definitions from a js/ts file in memory
+   *
+   * @param manifest - The imported XLR manifest module
+   * @param filters - Any filters to apply when loading the types (a positive match will omit)
+   * @param transforms - any transforms to apply to the types being loaded
+   */
+  async loadDefinitionsFromModule(manifest, filters, transforms) {
+    this.computedNodeCache.clear();
+    const transformsToRun = [
+      ...this.externalTransformFunctions.values(),
+      ...transforms ?? []
+    ];
+    Object.keys(manifest.capabilities)?.forEach((capabilityName) => {
+      if (filters?.capabilityFilter && capabilityName.match(filters?.capabilityFilter))
+        return;
+      const capabilityList = manifest.capabilities[capabilityName];
+      capabilityList.forEach((extension) => {
+        if (!filters?.typeFilter || !extension.name.match(filters?.typeFilter)) {
+          const effectiveType = transformsToRun?.reduce(
+            (typeAccumulator, transformFn) => transformFn(
+              typeAccumulator,
+              capabilityName
+            ),
+            extension
+          ) ?? extension;
+          this.registry.add(effectiveType, manifest.pluginName, capabilityName);
+        }
+      });
+    });
+  }
+  /**
+   * Statically load transform function that should be applied to every XLR bundle that is imported
+   */
+  addTransformFunction(name, fn) {
+    this.externalTransformFunctions.set(name, fn);
+  }
+  /**
+   * Remove any transform function loaded via the `addTransformFunction` method by name
+   */
+  removeTransformFunction(name) {
+    this.externalTransformFunctions.delete(name);
+  }
+  /**
+   * Returns a Type that has been previously loaded
+   *
+   * @param id - Type to retrieve
+   * @param options - `GetTypeOptions`
+   * @returns `NamedType<NodeType>` | `undefined`
+   */
+  getType(id, options) {
+    let type = this.registry.get(id);
+    if (options?.getRawType === true || !type) {
+      return type;
+    }
+    if (this.computedNodeCache.has(id)) {
+      return JSON.parse(JSON.stringify(this.computedNodeCache.get(id)));
+    }
+    type = this.resolveType(type, options?.optimize);
+    this.computedNodeCache.set(id, type);
+    return type;
+  }
+  /**
+   * Returns if a Type with `id` has been loaded into the DSK
+   *
+   * @param id - Type to retrieve
+   * @returns `boolean`
+   */
+  hasType(id) {
+    return this.registry.has(id);
+  }
+  /**
+   * Lists types that have been loaded into the SDK
+   *
+   * @param filters - Any filters to apply to the types returned (a positive match will omit)
+   * @returns `Array<NamedTypes>`
+   */
+  listTypes(filters) {
+    return this.registry.list(filters);
+  }
+  /**
+   * Returns meta information around a registered type
+   *
+   * @param id - Name of Type to retrieve
+   * @returns `TypeMetaData` | `undefined`
+   */
+  getTypeInfo(id) {
+    return this.registry.info(id);
+  }
+  /**
+   * Validates if a JSONC Node follows the XLR Type registered under the `typeName` specified
+   *
+   * @param typeName - Registered XLR Type to use for validation
+   * @param rootNode - Node to validate
+   * @returns `Array<ValidationErrors>`
+   */
+  validateByName(typeName, rootNode) {
+    const xlr = this.getType(typeName);
+    if (!xlr) {
+      throw new Error(
+        `Type ${typeName} does not exist in registry, can't validate`
+      );
+    }
+    return this.validator.validateType(rootNode, xlr);
+  }
+  /**
+   * Validates if a JSONC Node follows the supplied XLR Type
+   *
+   * @param type - Type to validate against
+   * @param rootNode - Node to validate
+   * @returns `Array<ValidationErrors>`
+   */
+  validateByType(type, rootNode) {
+    return this.validator.validateType(rootNode, type);
+  }
+  /**
+   * Exports the types loaded into the registry to the specified format
+   *
+   * @param exportType - what format to export as
+   * @param importMap - a map of primitive packages to types exported from that package to add import statements
+   * @param filters - filter out plugins/capabilities/types you don't want to export
+   * @param transforms - transforms to apply to types before exporting them
+   * @returns [filename, content][] - Tuples of filenames and content to write
+   */
+  exportRegistry(exportType, importMap, filters, transforms) {
+    const typesToExport = this.registry.list(filters).map((type) => {
+      const effectiveType = transforms?.reduce(
+        (typeAccumulator, transformFn) => transformFn(
+          typeAccumulator,
+          this.registry.info(type.name)?.capability
+        ),
+        type
+      ) ?? type;
+      return effectiveType;
+    });
+    if (exportType === "TypeScript") {
+      const outputString = this.exportToTypeScript(typesToExport, importMap);
+      return [["out.d.ts", outputString]];
+    }
+    throw new Error(`Unknown export format ${exportType}`);
+  }
+  /**
+   * Transforms a generated XLR node into its final representation by resolving all `extends` properties.
+   * If `optimize` is set to true the following operations are also performed:
+   *  - Solving any conditional types
+   *  - Computing the effective types of any union elements
+   *  - Resolving any ref nodes
+   *  - filing in any remaining generics with their default value
+   */
+  resolveType(type, optimize = true) {
+    const resolvedObject = fillInGenerics(type);
+    let transformMap = {
+      object: [(objectNode) => {
+        if (objectNode.extends) {
+          const refName = objectNode.extends.ref.split("<")[0];
+          let extendedType = this.getType(refName, { getRawType: true });
+          if (!extendedType) {
+            throw new Error(
+              `Error resolving ${objectNode.name}: can't find extended type ${refName}`
+            );
+          }
+          extendedType = resolveReferenceNode2(
+            objectNode.extends,
+            extendedType
+          );
+          if (extendedType.type === "object") {
+            return {
+              ...computeEffectiveObject2(
+                extendedType,
+                objectNode,
+                false
+              ),
+              name: objectNode.name,
+              description: objectNode.description
+            };
+          }
+          if (extendedType.type === "or") {
+            return {
+              ...this.validator.computeIntersectionType(
+                [
+                  objectNode,
+                  extendedType
+                ]
+              ),
+              name: objectNode.name,
+              description: objectNode.description
+            };
+          }
+          return {
+            name: objectNode.name,
+            type: "and",
+            and: [
+              {
+                ...objectNode,
+                extends: void 0
+              },
+              extendedType
+            ]
+          };
+        }
+        return objectNode;
+      }]
+    };
+    if (optimize) {
+      transformMap = {
+        ...transformMap,
+        conditional: [(node) => {
+          return resolveConditional2(node);
+        }],
+        and: [(node) => {
+          return {
+            ...this.validator.computeIntersectionType(node.and),
+            ...node.name ? { name: node.name } : {}
+          };
+        }],
+        ref: [(refNode) => {
+          return this.validator.getRefType(refNode);
+        }]
+      };
+    }
+    return xlrTransformWalker(transformMap)(resolvedObject);
+  }
+  exportToTypeScript(typesToExport, importMap) {
+    const referencedImports = /* @__PURE__ */ new Set();
+    const exportedTypes = /* @__PURE__ */ new Map();
+    const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+    let resultFile = ts.createSourceFile(
+      "output.d.ts",
+      "",
+      ts.ScriptTarget.ES2017,
+      false,
+      // setParentNodes
+      ts.ScriptKind.TS
+    );
+    typesToExport.forEach((typeNode) => {
+      const { type, referencedTypes, additionalTypes } = this.tsWriter.convertNamedType(typeNode);
+      exportedTypes.set(typeNode.name, type);
+      additionalTypes?.forEach(
+        (additionalType, name) => exportedTypes.set(name, additionalType)
+      );
+      referencedTypes?.forEach(
+        (referencedType) => referencedImports.add(referencedType)
+      );
+    });
+    const typesToPrint = [];
+    exportedTypes.forEach(
+      (type) => typesToPrint.push(
+        printer.printNode(ts.EmitHint.Unspecified, type, resultFile)
+      )
+    );
+    importMap.forEach((imports, packageName) => {
+      const applicableImports = imports.filter((i) => referencedImports.has(i));
+      resultFile = ts.factory.updateSourceFile(resultFile, [
+        ts.factory.createImportDeclaration(
+          /* modifiers */
+          void 0,
+          ts.factory.createImportClause(
+            false,
+            void 0,
+            ts.factory.createNamedImports(
+              applicableImports.map(
+                (i) => ts.factory.createImportSpecifier(
+                  false,
+                  void 0,
+                  ts.factory.createIdentifier(i)
+                )
+              )
+            )
+          ),
+          ts.factory.createStringLiteral(packageName)
+        ),
+        ...resultFile.statements
+      ]);
+    });
+    const headerText = printer.printFile(resultFile);
+    const nodeText = typesToPrint.join("\n");
+    return `${headerText}
+${nodeText}`;
+  }
+};
+export {
+  BasicXLRRegistry,
+  ValidationSeverity,
+  XLRSDK,
+  simpleTransformGenerator,
+  xlrTransformWalker
+};
+//# sourceMappingURL=index.mjs.map