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

package/dist/index.mjs

@@ -0,0 +1,821 @@
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/utils/src/annotations.ts
+import ts from "typescript";
+function extractDescription(text) {
+  if (!text) {
+    return {};
+  }
+  return { description: text };
+}
+function parentIsNonObjectPath(node) {
+  return node.parent && (ts.isArrayTypeNode(node.parent) || ts.isTupleTypeNode(node.parent) || ts.isOptionalTypeNode(node.parent) || ts.isRestTypeNode(node.parent) || ts.isUnionTypeNode(node.parent));
+}
+function recurseTypeChain(node, child) {
+  if (!node) {
+    return [];
+  }
+  if (ts.isArrayTypeNode(node) && node.parent && ts.isRestTypeNode(node.parent)) {
+    return recurseTypeChain(node.parent, node);
+  }
+  if (ts.isRestTypeNode(node)) {
+    return recurseTypeChain(node.parent, node);
+  }
+  if (ts.isOptionalTypeNode(node)) {
+    return recurseTypeChain(node.parent, node);
+  }
+  if (ts.isUnionTypeNode(node)) {
+    return recurseTypeChain(node.parent, node);
+  }
+  if (ts.isParenthesizedTypeNode(node)) {
+    return recurseTypeChain(node.parent, node);
+  }
+  if (ts.isTypeLiteralNode(node)) {
+    return recurseTypeChain(node.parent, node);
+  }
+  if (ts.isArrayTypeNode(node)) {
+    return ["[]", ...recurseTypeChain(node.parent, node)];
+  }
+  if (ts.isTupleTypeNode(node)) {
+    const pos = node.elements.indexOf(child);
+    return [
+      ...pos === -1 ? [] : [`${pos}`],
+      ...recurseTypeChain(node.parent, node)
+    ];
+  }
+  if (ts.isTypeAliasDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isPropertySignature(node)) {
+    return [node.name.getText(), ...recurseTypeChain(node.parent, node)];
+  }
+  if (parentIsNonObjectPath(node)) {
+    return recurseTypeChain(node.parent, node);
+  }
+  return [];
+}
+function extractTitle(node) {
+  const typeNames = recurseTypeChain(node, void 0).reverse().join(".");
+  if (!typeNames.length) {
+    return {};
+  }
+  return { title: typeNames };
+}
+function stringifyDoc(docString) {
+  if (typeof docString === "undefined" || typeof docString === "string") {
+    return docString;
+  }
+  return docString.map(({ text }) => text).join(" ");
+}
+function extractTags(tags) {
+  const descriptions = [];
+  const examples = [];
+  const _default = [];
+  const see = [];
+  const meta = {};
+  const extractSee = (tag) => {
+    return `${tag.tagName ? `${tag.tagName?.getText()} ` : ""}${stringifyDoc(tag.comment)?.trim() ?? ""}`;
+  };
+  tags.forEach((tag) => {
+    if (!tag.comment) {
+      return;
+    }
+    if (tag.tagName.text === "example") {
+      examples.push(stringifyDoc(tag.comment)?.trim() ?? "");
+    } else if (tag.tagName.text === "default") {
+      _default.push(stringifyDoc(tag.comment)?.trim() ?? "");
+    } else if (tag.tagName.text === "see") {
+      see.push(extractSee(tag));
+    } else if (tag.tagName.text === "meta") {
+      const [key, value] = tag.comment.toString().split(/:(.*)/);
+      meta[key] = value?.trim() ?? "";
+    } else {
+      const text = stringifyDoc(tag.comment)?.trim() ?? "";
+      descriptions.push(`@${tag.tagName.text} ${text}`);
+    }
+  });
+  return {
+    ...descriptions.length === 0 ? {} : { description: descriptions.join("\n") },
+    ...examples.length === 0 ? {} : { examples },
+    ..._default.length === 0 ? {} : { default: _default.join("\n") },
+    ...see.length === 0 ? {} : { see },
+    ...meta && Object.keys(meta).length === 0 ? {} : { meta }
+  };
+}
+function join(t, separator = "\n") {
+  const unique = new Set(t).values();
+  return Array.from(unique).filter((s) => s !== void 0).join(separator).trim();
+}
+function mergeAnnotations(nodes) {
+  const name = nodes.find((n) => n.name)?.name;
+  const title = join(
+    nodes.map((n) => n.title),
+    ", "
+  );
+  const description = join(nodes.map((n) => n.description));
+  const _default = join(nodes.map((n) => n.default));
+  const comment = join(nodes.map((n) => n.comment));
+  const examples = join(
+    nodes.map(
+      (n) => Array.isArray(n.examples) ? join(n.examples) : n.examples
+    )
+  );
+  const see = join(
+    nodes.map((n) => Array.isArray(n.see) ? join(n.see) : n.see)
+  );
+  const meta = nodes.find((n) => n.meta)?.meta;
+  return {
+    ...name ? { name } : {},
+    ...title ? { title } : {},
+    ...description ? { description } : {},
+    ...examples ? { examples } : {},
+    ..._default ? { default: _default } : {},
+    ...see ? { see } : {},
+    ...comment ? { comment } : {},
+    ...meta ? { meta } : {}
+  };
+}
+function decorateNode(node) {
+  const { jsDoc } = node;
+  const titleAnnotation = extractTitle(node);
+  if (jsDoc && jsDoc.length) {
+    const first = jsDoc[0];
+    return mergeAnnotations([
+      extractDescription(stringifyDoc(first.comment)),
+      titleAnnotation,
+      extractTags(first.tags ?? [])
+    ]);
+  }
+  return titleAnnotation;
+}
+
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/utils/src/ts-helpers.ts
+import ts3 from "typescript";
+
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/utils/src/type-checks.ts
+import ts2 from "typescript";
+function isOptionalProperty(node) {
+  return node.questionToken?.kind === ts2.SyntaxKind.QuestionToken;
+}
+function isGenericInterfaceDeclaration(node) {
+  const length = node.typeParameters?.length;
+  return length ? length > 0 : false;
+}
+function isGenericTypeDeclaration(node) {
+  const length = node.typeParameters?.length;
+  return length ? length > 0 : false;
+}
+function isTypeReferenceGeneric(node, typeChecker) {
+  const symbol = typeChecker.getSymbolAtLocation(node.typeName);
+  if (symbol && symbol.declarations) {
+    return symbol.declarations[0].kind === ts2.SyntaxKind.TypeParameter;
+  }
+  return false;
+}
+function isTopLevelDeclaration(node) {
+  return node.kind === ts2.SyntaxKind.InterfaceDeclaration || node.kind === ts2.SyntaxKind.TypeAliasDeclaration;
+}
+function isTopLevelNode(node) {
+  return node.kind === ts2.SyntaxKind.InterfaceDeclaration || node.kind === ts2.SyntaxKind.TypeAliasDeclaration || node.kind === ts2.SyntaxKind.VariableStatement;
+}
+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;
+}
+
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/utils/src/validation-helpers.ts
+function propertyToTuple(node) {
+  let key = node.children?.[0].value;
+  if (key.includes("-")) {
+    key = `'${key}'`;
+  }
+  return {
+    key,
+    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/ts-helpers.ts
+function tsStripOptionalType(node) {
+  return ts3.isOptionalTypeNode(node) ? node.type : node;
+}
+function isExportedDeclaration(node) {
+  const modifiers = ts3.canHaveModifiers(node) ? ts3.getModifiers(node) : void 0;
+  if (modifiers) {
+    return modifiers.some((m) => m.kind === ts3.SyntaxKind.ExportKeyword);
+  }
+  return false;
+}
+function isNodeExported(node) {
+  return (ts3.getCombinedModifierFlags(node) & ts3.ModifierFlags.Export) !== 0 || !!node.parent && node.parent.kind === ts3.SyntaxKind.SourceFile;
+}
+function getReferencedType(node, typeChecker) {
+  let symbol = typeChecker.getSymbolAtLocation(node.typeName);
+  if (symbol && (symbol.flags & ts3.SymbolFlags.Alias) === ts3.SymbolFlags.Alias) {
+    symbol = typeChecker.getAliasedSymbol(symbol);
+  }
+  const varDecl = symbol?.declarations?.[0];
+  if (varDecl && (ts3.isInterfaceDeclaration(varDecl) || ts3.isTypeAliasDeclaration(varDecl))) {
+    return { declaration: varDecl, exported: isNodeExported(varDecl) };
+  }
+}
+function getStringLiteralsFromUnion(node) {
+  if (ts3.isUnionTypeNode(node)) {
+    return new Set(
+      node.types.map((type) => {
+        if (ts3.isLiteralTypeNode(type) && ts3.isStringLiteral(type.literal)) {
+          return type.literal.text;
+        }
+        return "";
+      })
+    );
+  }
+  if (ts3.isLiteralTypeNode(node) && ts3.isStringLiteral(node.literal)) {
+    return /* @__PURE__ */ new Set([node.literal.text]);
+  }
+  return /* @__PURE__ */ new Set();
+}
+function buildTemplateRegex(node, typeChecker) {
+  let regex = node.head.text;
+  node.templateSpans.forEach((span) => {
+    let type = span.type.kind;
+    if (ts3.isTypeReferenceNode(span.type)) {
+      let symbol = typeChecker.getSymbolAtLocation(
+        span.type.typeName
+      );
+      if (symbol && (symbol.flags & ts3.SymbolFlags.Alias) === ts3.SymbolFlags.Alias) {
+        symbol = typeChecker.getAliasedSymbol(symbol);
+      }
+      type = (symbol?.declarations?.[0]).type.kind;
+    }
+    if (type === ts3.SyntaxKind.StringKeyword) {
+      regex += ".*";
+    } else if (type === ts3.SyntaxKind.NumberKeyword) {
+      regex += "[0-9]*";
+    } else if (type === ts3.SyntaxKind.BooleanKeyword) {
+      regex += "true|false";
+    }
+    regex += span.literal.text;
+  });
+  return regex;
+}
+function fillInGenerics(xlrNode, generics) {
+  let localGenerics;
+  if (generics) {
+    localGenerics = new Map(generics);
+  } 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)
+        );
+      });
+    }
+  }
+  if (xlrNode.type === "ref") {
+    if (localGenerics.has(xlrNode.ref)) {
+      return {
+        ...localGenerics.get(xlrNode.ref),
+        ...xlrNode.genericArguments ? {
+          genericArguments: xlrNode.genericArguments.map(
+            (ga) => fillInGenerics(ga, localGenerics)
+          )
+        } : {},
+        ...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)
+        )
+      } : {}
+    };
+  }
+  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)
+      };
+    });
+    return {
+      ...xlrNode,
+      properties: newProperties,
+      ...isGenericNamedType(xlrNode) ? {
+        genericTokens: xlrNode.genericTokens.map((token) => {
+          return {
+            ...token,
+            constraints: token.constraints ? fillInGenerics(token.constraints, localGenerics) : void 0,
+            default: token.default ? fillInGenerics(token.default, localGenerics) : void 0
+          };
+        })
+      } : {},
+      extends: xlrNode.extends ? fillInGenerics(xlrNode.extends, localGenerics) : void 0,
+      additionalProperties: xlrNode.additionalProperties ? fillInGenerics(xlrNode.additionalProperties, localGenerics) : false
+    };
+  }
+  if (xlrNode.type === "array") {
+    return {
+      ...xlrNode,
+      elementType: fillInGenerics(xlrNode.elementType, localGenerics)
+    };
+  } 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);
+      })
+    };
+  } else if (xlrNode.type === "record") {
+    return {
+      ...xlrNode,
+      keyType: fillInGenerics(xlrNode.keyType, localGenerics),
+      valueType: fillInGenerics(xlrNode.valueType, localGenerics)
+    };
+  } else if (xlrNode.type === "conditional") {
+    const filledInConditional = {
+      ...xlrNode,
+      check: {
+        left: fillInGenerics(xlrNode.check.left, localGenerics),
+        right: fillInGenerics(xlrNode.check.right, localGenerics)
+      },
+      value: {
+        true: fillInGenerics(xlrNode.value.true, localGenerics),
+        false: fillInGenerics(xlrNode.value.false, localGenerics)
+      }
+    };
+    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
+  };
+}
+
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/utils/src/documentation.ts
+import ts4 from "typescript";
+var { SymbolDisplayPartKind, displayPartsToString } = ts4;
+function insertBetweenElements(array, separator) {
+  return array.reduce((acc, item, index) => {
+    if (index === 0) {
+      return [item];
+    }
+    return [...acc, separator, item];
+  }, []);
+}
+function createTSDocString(node) {
+  if (node.type === "ref") {
+    return [
+      {
+        text: node.ref,
+        kind: SymbolDisplayPartKind.keyword
+      }
+    ];
+  }
+  if (node.type === "or" || node.type === "and") {
+    const items = node.type === "and" ? node.and : node.or;
+    return insertBetweenElements(
+      items.map((subnode) => createTSDocString(subnode)),
+      [
+        {
+          kind: SymbolDisplayPartKind.punctuation,
+          text: node.type === "and" ? " & " : " | "
+        }
+      ]
+    ).flat();
+  }
+  if (node.type === "function") {
+    return [
+      {
+        kind: SymbolDisplayPartKind.keyword,
+        text: "function"
+      },
+      {
+        kind: SymbolDisplayPartKind.space,
+        text: " "
+      },
+      ...node.name ? [{ text: node.name, kind: SymbolDisplayPartKind.methodName }] : [],
+      {
+        kind: SymbolDisplayPartKind.punctuation,
+        text: "("
+      },
+      ...insertBetweenElements(
+        node.parameters.map((p) => {
+          if (p.name) {
+            return [
+              {
+                kind: SymbolDisplayPartKind.parameterName,
+                text: p.name
+              },
+              {
+                kind: SymbolDisplayPartKind.punctuation,
+                text: p.optional ? "?" : ""
+              },
+              {
+                kind: SymbolDisplayPartKind.punctuation,
+                text: ": "
+              },
+              ...createTSDocString(p.type)
+            ];
+          }
+          return createTSDocString(p.type);
+        }),
+        [
+          {
+            kind: SymbolDisplayPartKind.punctuation,
+            text: ", "
+          }
+        ]
+      ).flat(),
+      {
+        kind: SymbolDisplayPartKind.punctuation,
+        text: ")"
+      },
+      ...node.returnType ? [
+        {
+          kind: SymbolDisplayPartKind.punctuation,
+          text: ": "
+        },
+        ...createTSDocString(node.returnType)
+      ] : []
+    ];
+  }
+  if (node.type === "tuple") {
+    return [
+      {
+        kind: SymbolDisplayPartKind.punctuation,
+        text: "["
+      },
+      ...insertBetweenElements(
+        node.elementTypes.map((t) => {
+          if (t.name) {
+            return [
+              {
+                kind: SymbolDisplayPartKind.propertyName,
+                text: t.name
+              },
+              {
+                kind: SymbolDisplayPartKind.punctuation,
+                text: ": "
+              },
+              ...createTSDocString(t.type)
+            ];
+          }
+          return createTSDocString(t.type);
+        }),
+        [
+          {
+            kind: SymbolDisplayPartKind.punctuation,
+            text: ", "
+          }
+        ]
+      ).flat(),
+      {
+        kind: SymbolDisplayPartKind.punctuation,
+        text: "]"
+      }
+    ];
+  }
+  if (node.type === "array") {
+    return [
+      {
+        kind: SymbolDisplayPartKind.interfaceName,
+        text: "Array"
+      },
+      {
+        kind: SymbolDisplayPartKind.punctuation,
+        text: "<"
+      },
+      ...createTSDocString(node.elementType),
+      {
+        kind: SymbolDisplayPartKind.punctuation,
+        text: ">"
+      }
+    ];
+  }
+  if (node.type === "record") {
+    return [
+      {
+        kind: SymbolDisplayPartKind.interfaceName,
+        text: "Record"
+      },
+      {
+        kind: SymbolDisplayPartKind.punctuation,
+        text: "<"
+      },
+      ...createTSDocString(node.keyType),
+      {
+        kind: SymbolDisplayPartKind.punctuation,
+        text: ", "
+      },
+      ...createTSDocString(node.valueType),
+      {
+        kind: SymbolDisplayPartKind.punctuation,
+        text: ">"
+      }
+    ];
+  }
+  if ((node.type === "string" || node.type === "boolean" || node.type === "number") && node.const !== void 0) {
+    return [
+      {
+        kind: SymbolDisplayPartKind.keyword,
+        text: typeof node.const === "string" ? `"${node.const}"` : String(node.const)
+      }
+    ];
+  }
+  if (isPrimitiveTypeNode(node) && node.type !== "null") {
+    return [
+      {
+        kind: SymbolDisplayPartKind.keyword,
+        text: node.type
+      }
+    ];
+  }
+  if (node.type === "object" && node.name) {
+    return [
+      {
+        kind: SymbolDisplayPartKind.interfaceName,
+        text: node.name
+      }
+    ];
+  }
+  return [
+    {
+      kind: SymbolDisplayPartKind.localName,
+      text: node.type
+    }
+  ];
+}
+function symbolDisplayToString(displayParts) {
+  return displayPartsToString(displayParts);
+}
+function createDocString(node) {
+  return symbolDisplayToString(createTSDocString(node));
+}
+export {
+  applyExcludeToNodeType,
+  applyPartialOrRequiredToNodeType,
+  applyPickOrOmitToNodeType,
+  buildTemplateRegex,
+  computeEffectiveObject,
+  computeExtends,
+  createDocString,
+  createTSDocString,
+  decorateNode,
+  fillInGenerics,
+  getReferencedType,
+  getStringLiteralsFromUnion,
+  isExportedDeclaration,
+  isGenericInterfaceDeclaration,
+  isGenericNamedType,
+  isGenericNodeType,
+  isGenericTypeDeclaration,
+  isNode,
+  isNodeExported,
+  isNonNullable,
+  isOptionalProperty,
+  isPrimitiveTypeNode,
+  isTopLevelDeclaration,
+  isTopLevelNode,
+  isTypeReferenceGeneric,
+  makePropertyMap,
+  propertyToTuple,
+  resolveConditional,
+  resolveReferenceNode,
+  symbolDisplayToString,
+  tsStripOptionalType
+};
+//# sourceMappingURL=index.mjs.map