@xlr-lib/xlr-utils 0.2.0--canary.2.120 → 1.0.0

package/dist/index.mjs

@@ -1,178 +1,4 @@
-// ../../../../../../../../../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;
 }
@@ -218,12 +44,8 @@ function isNamedType(node) {
 
 // ../../../../../../../../../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,
+    key: node.children?.[0].value,
     value: node.children?.[1]
   };
 }
@@ -358,89 +180,20 @@ function computeEffectiveObject(base, operand, errorOnOverlap = true) {
   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 isTypeScriptLibType(node, typeChecker) {
-  let symbol = typeChecker.getSymbolAtLocation(node.typeName);
-  if (!symbol) return false;
-  if ((symbol.flags & ts3.SymbolFlags.Alias) === ts3.SymbolFlags.Alias) {
-    symbol = typeChecker.getAliasedSymbol(symbol);
-  }
-  const declarations = symbol.getDeclarations();
-  if (!declarations || declarations.length === 0) return false;
-  return declarations.some((decl) => {
-    const sourceFile = decl.getSourceFile();
-    if (!sourceFile) return false;
-    const filePath = sourceFile.fileName;
-    return filePath.includes("/typescript/lib/") || filePath.includes("\\typescript\\lib\\") || filePath.endsWith(".d.ts") && filePath.includes("lib.");
-  });
-}
-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) {
+// ../../../../../../../../../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)) {
@@ -448,7 +201,7 @@ function fillInGenerics(xlrNode, generics) {
         const genericValue = token.default ?? token.constraints;
         localGenerics.set(
           token.symbol,
-          fillInGenerics(genericValue, localGenerics)
+          fillInGenerics(genericValue, localGenerics, preferLocalGenerics)
         );
       });
     }
@@ -459,7 +212,7 @@ function fillInGenerics(xlrNode, generics) {
         ...localGenerics.get(xlrNode.ref),
         ...xlrNode.genericArguments ? {
           genericArguments: xlrNode.genericArguments.map(
-            (ga) => fillInGenerics(ga, localGenerics)
+            (ga) => fillInGenerics(ga, localGenerics, preferLocalGenerics)
           )
         } : {},
         ...xlrNode.title ? { title: xlrNode.title } : {},
@@ -472,7 +225,7 @@ function fillInGenerics(xlrNode, generics) {
       ...xlrNode,
       ...xlrNode.genericArguments ? {
         genericArguments: xlrNode.genericArguments.map(
-          (ga) => fillInGenerics(ga, localGenerics)
+          (ga) => fillInGenerics(ga, localGenerics, preferLocalGenerics)
         )
       } : {}
     };
@@ -483,7 +236,7 @@ function fillInGenerics(xlrNode, generics) {
       const prop = xlrNode.properties[propName];
       newProperties[propName] = {
         required: prop.required,
-        node: fillInGenerics(prop.node, localGenerics)
+        node: fillInGenerics(prop.node, localGenerics, preferLocalGenerics)
       };
     });
     return {
@@ -493,19 +246,39 @@ function fillInGenerics(xlrNode, generics) {
         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
+            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) : void 0,
-      additionalProperties: xlrNode.additionalProperties ? fillInGenerics(xlrNode.additionalProperties, localGenerics) : false
+      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)
+      elementType: fillInGenerics(
+        xlrNode.elementType,
+        localGenerics,
+        preferLocalGenerics
+      )
     };
   } else if (xlrNode.type === "or" || xlrNode.type === "and") {
     let pointer;
@@ -517,25 +290,49 @@ function fillInGenerics(xlrNode, generics) {
     return {
       ...xlrNode,
       [xlrNode.type]: pointer.map((prop) => {
-        return fillInGenerics(prop, localGenerics);
+        return fillInGenerics(prop, localGenerics, preferLocalGenerics);
       })
     };
   } else if (xlrNode.type === "record") {
     return {
       ...xlrNode,
-      keyType: fillInGenerics(xlrNode.keyType, localGenerics),
-      valueType: fillInGenerics(xlrNode.valueType, localGenerics)
+      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),
-        right: fillInGenerics(xlrNode.check.right, localGenerics)
+        left: fillInGenerics(
+          xlrNode.check.left,
+          localGenerics,
+          preferLocalGenerics
+        ),
+        right: fillInGenerics(
+          xlrNode.check.right,
+          localGenerics,
+          preferLocalGenerics
+        )
       },
       value: {
-        true: fillInGenerics(xlrNode.value.true, localGenerics),
-        false: fillInGenerics(xlrNode.value.false, localGenerics)
+        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") {
@@ -629,249 +426,31 @@ function applyExcludeToNodeType(baseObject, filters) {
     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,
   isAndType,
   isArrayType,
   isBooleanType,
-  isExportedDeclaration,
-  isGenericInterfaceDeclaration,
   isGenericNamedType,
   isGenericNodeType,
-  isGenericTypeDeclaration,
   isNamedType,
   isNode,
-  isNodeExported,
   isNonNullable,
   isNumberType,
   isObjectType,
-  isOptionalProperty,
   isOrType,
   isPrimitiveTypeNode,
   isRecordType,
   isRefType,
   isStringType,
-  isTopLevelDeclaration,
-  isTopLevelNode,
-  isTypeReferenceGeneric,
-  isTypeScriptLibType,
   makePropertyMap,
   propertyToTuple,
   resolveConditional,
-  resolveReferenceNode,
-  symbolDisplayToString,
-  tsStripOptionalType
+  resolveReferenceNode
 };
 //# sourceMappingURL=index.mjs.map