@xyd-js/sources 0.0.0-build

package/dist/ts.cjs

@@ -0,0 +1,1794 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/ts/index.ts
+var ts_exports = {};
+__export(ts_exports, {
+  sourcesToUniformV2: () => sourcesToUniformV2,
+  uniformToMiniUniform: () => uniformToMiniUniform
+});
+module.exports = __toCommonJS(ts_exports);
+var path2 = __toESM(require("path"), 1);
+var import_path = require("path");
+var import_typescript = __toESM(require("typescript"), 1);
+var TypeDoc = __toESM(require("typedoc"), 1);
+
+// packages/ts/TypeDocTransformer.ts
+var fs2 = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var import_typedoc = require("typedoc");
+var import_uniform = require("@xyd-js/uniform");
+
+// packages/ts/SignatureText.ts
+var ts = __toESM(require("typescript"), 1);
+var fs = __toESM(require("fs"), 1);
+var printer = ts.createPrinter({ removeComments: true });
+var SignatureTextLoader = class {
+  constructor(sourcePath) {
+    const source = fs.readFileSync(sourcePath, "utf-8");
+    this.sourceFile = ts.createSourceFile(
+      sourcePath,
+      source,
+      ts.ScriptTarget.Latest,
+      true
+    );
+  }
+};
+var MultiSignatureLoader = class {
+  constructor() {
+    this.loaders = /* @__PURE__ */ new Map();
+  }
+  load(path3) {
+    if (this.loaders.has(path3)) {
+      return this.loaders.get(path3);
+    }
+    const loader = new SignatureTextLoader(path3);
+    this.loaders.set(path3, loader);
+    return loader;
+  }
+};
+function signatureTextByLine(sign, targetLine, options) {
+  return signatureText.call(sign, targetLine, options);
+}
+function signatureSourceCodeByLine(sign, targetLine) {
+  return signatureSourceCode.call(sign, targetLine);
+}
+function signatureText(targetLine, options) {
+  const sourceFile = this.sourceFile;
+  const signatureNode = findSignatureNode.call(
+    this,
+    sourceFile,
+    [targetLine]
+  );
+  if (!signatureNode) {
+    console.error("(signatureText): `signatureNode` is empty, something went wrong");
+    return;
+  }
+  const printableSignatureNode = nodeToPrintableSignatureNode(signatureNode, options == null ? void 0 : options.typeOnly);
+  if (!printableSignatureNode) {
+    console.error("(signatureText): cannot convert `signatureNode` to `printableSignatureNode`");
+    return;
+  }
+  return printer.printNode(ts.EmitHint.Unspecified, printableSignatureNode, sourceFile).trim();
+}
+function findSignatureNode(node, targetLines) {
+  let isSourceFile = false;
+  if (node === node.getSourceFile()) {
+    isSourceFile = true;
+  }
+  if (!isSourceFile && isNodeAtLine(node, targetLines, this.sourceFile)) {
+    return node;
+  }
+  let signatureNode;
+  ts.forEachChild(node, (n) => {
+    if (signatureNode) {
+      return;
+    }
+    signatureNode = findSignatureNode.call(this, n, targetLines);
+  });
+  return signatureNode;
+}
+function signatureSourceCode(targetLine) {
+  const sourceFile = this.sourceFile;
+  const signatureNode = findSignatureNode.call(
+    this,
+    sourceFile,
+    [targetLine]
+  );
+  if (!signatureNode) {
+    console.error("(signatureSourceCode): `signatureNode` is empty, something went wrong");
+    return;
+  }
+  const start = signatureNode.getStart(sourceFile);
+  const end = signatureNode.getEnd();
+  return sourceFile.text.substring(start, end).trim();
+}
+function nodeToPrintableSignatureNode(node, typeOnly = false) {
+  if (typeOnly) {
+    if ("type" in node) {
+      return node.type;
+    }
+    return;
+  }
+  let resp;
+  if (ts.isFunctionDeclaration(node)) {
+    resp = ts.factory.updateFunctionDeclaration(
+      node,
+      node.modifiers,
+      node.asteriskToken,
+      node.name,
+      node.typeParameters,
+      node.parameters,
+      node.type,
+      void 0
+    );
+  } else if (ts.isClassDeclaration(node)) {
+    resp = ts.factory.updateClassDeclaration(
+      node,
+      node.modifiers,
+      node.name,
+      node.typeParameters,
+      node.heritageClauses,
+      []
+    );
+  } else if (ts.isInterfaceDeclaration(node)) {
+    resp = ts.factory.updateInterfaceDeclaration(
+      node,
+      node.modifiers,
+      node.name,
+      node.typeParameters,
+      node.heritageClauses,
+      []
+    );
+  } else if (ts.isEnumDeclaration(node)) {
+    resp = ts.factory.updateEnumDeclaration(
+      node,
+      node.modifiers,
+      node.name,
+      []
+    );
+  } else if (ts.isTypeAliasDeclaration(node)) {
+    resp = ts.factory.updateTypeAliasDeclaration(
+      node,
+      node.modifiers,
+      node.name,
+      node.typeParameters,
+      node.type
+    );
+  } else if (ts.isPropertySignature(node)) {
+    resp = ts.factory.updatePropertySignature(
+      node,
+      node.modifiers,
+      node.name,
+      node.questionToken,
+      node.type
+    );
+  } else {
+    resp = node;
+  }
+  if (!resp) {
+    console.error("(nodeToPrintableSignatureNode): resp is empty, something went wrong");
+    return;
+  }
+  return resp;
+}
+function isNodeAtLine(node, lines, sf) {
+  const { line: startLine } = sf.getLineAndCharacterOfPosition(node.getStart());
+  return lines.includes(startLine + 1);
+}
+
+// packages/ts/TypeDocTransformer.ts
+var TypeDocSignatureTextLoader = class extends MultiSignatureLoader {
+  constructor(project, packagePathMap) {
+    super();
+    this.project = project;
+    this.packagePathMap = packagePathMap;
+  }
+  signatureText(id, line, options) {
+    const loader = this.getSignatuerLoader(id);
+    if (!loader) {
+      return;
+    }
+    const signTxt = signatureTextByLine(loader, line, options);
+    if (!signTxt) {
+      console.warn("(TypeDocSignatureTextLoader.signatureText): Signature text is empty", id);
+      return;
+    }
+    return signTxt;
+  }
+  signatureSourceCode(id, line) {
+    const loader = this.getSignatuerLoader(id);
+    if (!loader) {
+      return;
+    }
+    const sourceCode = signatureSourceCodeByLine(loader, line);
+    if (!sourceCode) {
+      console.warn("(TypeDocSignatureTextLoader.signatureSourceCode): Source code is empty", id);
+      return;
+    }
+    return sourceCode;
+  }
+  getSignatuerLoader(id) {
+    const symbolMap = this.project.symbolIdMap[id];
+    if (!symbolMap) {
+      console.warn("(TypeDocSignatureTextLoader.getSignatuerLoader): Symbol not found", id);
+      return;
+    }
+    const fullPath = this.packagePathMap[id];
+    if (!fullPath) {
+      console.warn("(TypeDocSignatureTextLoader.getSignatuerLoader): Package path not found for symbol", symbolMap.packageName);
+      return;
+    }
+    const loader = this.load(fullPath);
+    if (!loader) {
+      console.warn("(TypeDocSignatureTextLoader.getSignatuerLoader): Loader not found", fullPath);
+      return;
+    }
+    return loader;
+  }
+};
+var Transformer = class {
+  constructor(rootPath, project, references = []) {
+    this.rootPath = rootPath;
+    this.project = project;
+    this.references = references;
+    this.packagePathMap = {};
+    const packagePathMap = this.createPackagePathMap();
+    if (packagePathMap) {
+      this.packagePathMap = packagePathMap;
+    }
+  }
+  createPackagePathMap() {
+    const packagePathMap = {};
+    const packageJsonPaths = this.findPackageJsonPaths(this.rootPath);
+    if (!packageJsonPaths.length) {
+      console.warn("(Transformer.createPackagePathMap): No package.json found in rootPath", this.rootPath);
+      return { packageMap: null, moduleRootMap: null };
+    }
+    for (const packageJsonPath of packageJsonPaths) {
+      const packageJson = JSON.parse(fs2.readFileSync(packageJsonPath, "utf-8"));
+      const packageName = packageJson.name;
+      const moduleRoot = path.dirname(packageJsonPath);
+      if (!packageName) {
+        console.warn("(Transformer.createPackagePathMap): Package name not found in package.json", packageJsonPath);
+        continue;
+      }
+      for (const id in this.project.symbolIdMap) {
+        const symbolMap = this.project.symbolIdMap[id];
+        if (symbolMap.packageName === packageName) {
+          const fullPath = path.join(moduleRoot, symbolMap.packagePath);
+          packagePathMap[Number.parseInt(id)] = fullPath;
+        }
+      }
+    }
+    return packagePathMap;
+  }
+  findPackageJsonPaths(dir) {
+    let results = [];
+    const list = fs2.readdirSync(dir);
+    for (const file of list) {
+      const filePath = path.join(dir, file);
+      const stat = fs2.statSync(filePath);
+      if (stat && stat.isDirectory()) {
+        if (file === "node_modules") {
+          continue;
+        }
+        results = results.concat(this.findPackageJsonPaths(filePath));
+      } else if (file === "package.json") {
+        results.push(filePath);
+      }
+    }
+    return results;
+  }
+};
+function typedocToUniform(rootPath, project) {
+  const references = [];
+  const transformer = new Transformer(
+    rootPath,
+    project,
+    references
+  );
+  const signatureTextLoader = new TypeDocSignatureTextLoader(
+    project,
+    transformer.packagePathMap
+  );
+  transformer.signatureTextLoader = signatureTextLoader;
+  if (project.kind !== import_typedoc.ReflectionKind.Project) {
+    throw new Error("Project reflection expected");
+  }
+  for (const child of project.children || []) {
+    if (!("kind" in child)) {
+      throw new Error("(typedocToUniform): Child reflection expected in project childrens");
+    }
+    if (typeof child.kind != "number") {
+      throw new Error("(typedocToUniform): Child reflection kind expected to be a number");
+    }
+    if (!child.kind) {
+      throw new Error("(typedocToUniform): Child reflection kind expected to be a valid ReflectionKind");
+    }
+    const kind = child.kind;
+    switch (kind) {
+      case import_typedoc.ReflectionKind.Module: {
+        const container = child;
+        for (const group of container.children || []) {
+          const ref = typedocGroupToUniform.call(
+            transformer,
+            group
+          );
+          if (!ref) {
+            continue;
+          }
+          ref.context = {
+            ...ref.context,
+            packageName: container.name
+          };
+          references.push(ref);
+        }
+        break;
+      }
+      case import_typedoc.ReflectionKind.Function:
+      case import_typedoc.ReflectionKind.Class:
+      case import_typedoc.ReflectionKind.Interface: {
+        if (!("kind" in child) || child.kind !== import_typedoc.ReflectionKind.Function && child.kind !== import_typedoc.ReflectionKind.Class && child.kind !== import_typedoc.ReflectionKind.Interface) {
+          throw new Error("(typedocToUniform): Function/Class/Interface reflection expected to be a DeclarationReflection");
+        }
+        const ref = typedocGroupToUniform.call(
+          transformer,
+          child
+        );
+        if (!ref) {
+          break;
+        }
+        ref.context = {
+          ...ref.context,
+          packageName: project.name
+        };
+        references.push(ref);
+        break;
+      }
+      case import_typedoc.ReflectionKind.TypeAlias: {
+        if (!("kind" in child) || child.kind !== import_typedoc.ReflectionKind.TypeAlias) {
+          throw new Error("(typedocToUniform): Type alias reflection expected to be a DeclarationReflection");
+        }
+        const ref = jsTypeAliasToUniformRef.call(
+          transformer,
+          child
+        );
+        if (!ref) {
+          break;
+        }
+        ref.context = {
+          ...ref.context,
+          packageName: project.name
+        };
+        references.push(ref);
+        break;
+      }
+      case import_typedoc.ReflectionKind.Enum: {
+        if (!("kind" in child) || child.kind !== import_typedoc.ReflectionKind.Enum) {
+          throw new Error("(typedocToUniform): Enum reflection expected to be a DeclarationReflection");
+        }
+        const ref = jsEnumToUniformRef.call(
+          transformer,
+          child
+        );
+        if (!ref) {
+          break;
+        }
+        ref.context = {
+          ...ref.context,
+          packageName: project.name
+        };
+        references.push(ref);
+        break;
+      }
+      default: {
+        console.warn("(typedocToUniform): Another children project kind not supported", child.kind);
+      }
+    }
+  }
+  references.sort((a, b) => {
+    const contextA = a.context;
+    const contextB = b.context;
+    const filePathA = (contextA == null ? void 0 : contextA.fileFullPath) || "";
+    const filePathB = (contextB == null ? void 0 : contextB.fileFullPath) || "";
+    if (filePathA !== filePathB) {
+      return filePathA.localeCompare(filePathB);
+    }
+    const lineA = (contextA == null ? void 0 : contextA.line) || 0;
+    const lineB = (contextB == null ? void 0 : contextB.line) || 0;
+    return lineA - lineB;
+  });
+  return references;
+}
+function typedocGroupToUniform(group) {
+  let ref;
+  switch (group.kind) {
+    case import_typedoc.ReflectionKind.Class: {
+      ref = jsClassToUniformRef.call(this, group);
+      break;
+    }
+    case import_typedoc.ReflectionKind.Function: {
+      ref = jsFunctionToUniformRef.call(this, group);
+      break;
+    }
+    case import_typedoc.ReflectionKind.Interface: {
+      ref = jsInterfaceToUniformRef.call(this, group);
+      break;
+    }
+    case import_typedoc.ReflectionKind.Enum: {
+      ref = jsEnumToUniformRef.call(this, group);
+      break;
+    }
+    case import_typedoc.ReflectionKind.TypeAlias: {
+      ref = jsTypeAliasToUniformRef.call(this, group);
+      break;
+    }
+    default: {
+      console.warn("(typedocGroupToUniform): Unhandled reflection kind", group.kind);
+    }
+  }
+  return ref;
+}
+function jsClassToUniformRef(dec) {
+  var _a, _b, _c, _d;
+  const definitions = [];
+  const ref = {
+    title: `Class ${dec.name}`,
+    canonical: "",
+    description: "",
+    context: void 0,
+    examples: {
+      groups: []
+    },
+    definitions
+  };
+  const declarationCtx = declarationUniformContext.call(this, dec);
+  if (declarationCtx) {
+    ref.context = {
+      ...ref.context,
+      ...declarationCtx
+    };
+  }
+  ref.canonical = uniformCanonical(dec, declarationCtx);
+  if (dec.comment) {
+    const description = commentToUniformDescription(dec.comment);
+    const group = uniformGroup(declarationCtx);
+    if (ref.context) {
+      ref.context.group = [
+        ...group,
+        "Classes"
+      ];
+    }
+    ref.description = description;
+  }
+  {
+    const constructor = (_a = dec.children) == null ? void 0 : _a.find((child) => child.name === "constructor");
+    if ((_b = constructor == null ? void 0 : constructor.signatures) == null ? void 0 : _b[0]) {
+      const constructorDef = {
+        title: "Constructor",
+        properties: []
+      };
+      const constructorSign = constructor.signatures[0];
+      for (const param of constructorSign.parameters || []) {
+        if (!param.type) {
+          console.warn("(jsClassToUniformRef): Constructor parameter type not found", param.name);
+          continue;
+        }
+        let description = "";
+        if (param.comment) {
+          description = commentToUniformDescription(param.comment);
+        }
+        let uniformType = someTypeToUniform.call(this, param.type);
+        let someTypeProps = {};
+        if (typeof uniformType === "object") {
+          delete uniformType.ofType;
+          someTypeProps = uniformType;
+        }
+        constructorDef.properties.push({
+          name: param.name,
+          type: typeof uniformType === "string" ? uniformType : "",
+          description,
+          ...someTypeProps
+        });
+      }
+      definitions.push(constructorDef);
+    }
+  }
+  {
+    const methods = ((_c = dec.children) == null ? void 0 : _c.filter(
+      (child) => child.kind === import_typedoc.ReflectionKind.Method && child.name !== "constructor"
+    )) || [];
+    if (methods.length > 0) {
+      const methodsDef = {
+        title: "Methods",
+        properties: []
+      };
+      for (const method of methods) {
+        if (!((_d = method.signatures) == null ? void 0 : _d[0])) continue;
+        const methodSign = method.signatures[0];
+        let methodDesc = "";
+        if (methodSign.comment) {
+          methodDesc = commentToUniformDescription(methodSign.comment);
+        }
+        let type = "";
+        let someTypeProps = {};
+        if (methodSign.type) {
+          if (typeof methodSign.type === "object") {
+            someTypeProps = methodSign.type;
+          }
+          type = typeof methodSign.type === "string" ? methodSign.type : "";
+        } else {
+          type = "void";
+        }
+        const property = {
+          name: method.name,
+          type,
+          description: methodDesc,
+          ...someTypeProps
+        };
+        if (method.comment) {
+          const examples = commentToUniformExamples(method.comment);
+          if (examples.length > 0) {
+            property.examples = examples;
+          }
+        }
+        methodsDef.properties.push(property);
+      }
+      definitions.push(methodsDef);
+    }
+  }
+  return ref;
+}
+function jsFunctionToUniformRef(dec) {
+  const definitions = [];
+  const ref = {
+    title: `Function ${dec.name}`,
+    canonical: "",
+    description: "",
+    context: void 0,
+    examples: {
+      groups: []
+    },
+    definitions
+  };
+  const declarationCtx = declarationUniformContext.call(this, dec);
+  if (declarationCtx) {
+    ref.context = {
+      ...ref.context,
+      ...declarationCtx
+    };
+  }
+  ref.canonical = uniformCanonical(dec, declarationCtx);
+  const signatures = dec.signatures || [];
+  if (signatures.length > 1) {
+    console.error("(jsFunctionToUniformRef): Multiple signatures not supported for function declaration", dec.name);
+    return;
+  }
+  for (const sign of dec.signatures || []) {
+    {
+      if (sign.comment) {
+        const description = commentToUniformDescription(sign.comment);
+        const group = uniformGroup(declarationCtx);
+        if (ref.context) {
+          ref.context.group = [
+            ...group,
+            "Functions"
+          ];
+        }
+        ref.description = description;
+      }
+    }
+    {
+      const meta = [
+        {
+          name: "type",
+          value: "returns"
+        }
+      ];
+      const returnsUniformDef = {
+        title: "Returns",
+        properties: [],
+        meta
+      };
+      if (sign.type) {
+        let desc = "";
+        if (sign.comment) {
+          desc = returnCommentToUniform(sign.comment) || "";
+        }
+        const uniformType = someTypeToUniform.call(this, sign.type);
+        let someTypeProps = {};
+        if (typeof uniformType === "object") {
+          delete uniformType.ofType;
+          someTypeProps = uniformType;
+        }
+        returnsUniformDef.properties.push({
+          name: "",
+          type: typeof uniformType === "string" ? uniformType : "",
+          description: desc,
+          ...someTypeProps
+        });
+      }
+      ref.definitions.push(returnsUniformDef);
+    }
+    {
+      const meta = [
+        {
+          name: "type",
+          value: "parameters"
+        }
+      ];
+      const parametersUniformDef = {
+        title: "Parameters",
+        properties: [],
+        meta
+      };
+      for (const param of sign.parameters || []) {
+        if (!param.type) {
+          console.warn("(jsFunctionToUniformRef): Parameter type not found", param.name);
+          continue;
+        }
+        let description = "";
+        if (param.comment) {
+          description = commentToUniformDescription(param.comment);
+        }
+        const uniformType = someTypeToUniform.call(this, param.type);
+        let someTypeProps = {};
+        if (typeof uniformType === "object") {
+          delete uniformType.ofType;
+          someTypeProps = uniformType;
+        }
+        const prop = {
+          name: param.name,
+          type: typeof uniformType === "string" ? uniformType : "",
+          description,
+          ...someTypeProps
+        };
+        switch (prop.name) {
+          case "__namedParameters": {
+            prop.name = "";
+            prop.type = import_uniform.DEFINED_DEFINITION_PROPERTY_TYPE.UNION;
+            break;
+          }
+        }
+        if (param.comment) {
+          const examples = commentToUniformExamples(param.comment);
+          if (examples.length > 0) {
+            prop.examples = examples;
+          }
+        }
+        parametersUniformDef.properties.push(prop);
+      }
+      ref.definitions.push(parametersUniformDef);
+    }
+  }
+  return ref;
+}
+function jsInterfaceToUniformRef(dec) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const definitions = [];
+  const ref = {
+    title: `Interface ${dec.name}`,
+    canonical: "",
+    description: "",
+    context: void 0,
+    examples: {
+      groups: []
+    },
+    definitions
+  };
+  const declarationCtx = declarationUniformContext.call(this, dec);
+  if (declarationCtx) {
+    ref.context = {
+      ...ref.context,
+      ...declarationCtx
+    };
+  }
+  ref.canonical = uniformCanonical(dec, declarationCtx);
+  if (dec.comment) {
+    const description = commentToUniformDescription(dec.comment);
+    const group = uniformGroup(declarationCtx);
+    if (ref.context) {
+      ref.context.group = [
+        ...group,
+        "Interfaces"
+      ];
+    }
+    ref.description = description;
+  }
+  {
+    const properties = ((_a = dec.children) == null ? void 0 : _a.filter(
+      (child) => child.kind === import_typedoc.ReflectionKind.Property
+    )) || [];
+    if (properties.length > 0) {
+      const propertiesDef = {
+        title: "Properties",
+        properties: []
+      };
+      for (const prop of properties) {
+        if (!prop.type) {
+          console.warn("(jsInterfaceToUniformRef): Property type not found", prop.name);
+          continue;
+        }
+        let description = "";
+        if (prop.comment) {
+          description = commentToUniformDescription(prop.comment);
+        }
+        const uniformType = someTypeToUniform.call(this, prop.type);
+        let someTypeProps = {};
+        let meta = [];
+        if (typeof uniformType === "object") {
+          delete uniformType.ofType;
+          someTypeProps = uniformType;
+          meta = uniformType.meta || [];
+        }
+        if (!((_b = prop.flags) == null ? void 0 : _b.isOptional)) {
+          meta.push({
+            name: "required",
+            value: "true"
+          });
+        }
+        if (Array.isArray((_c = prop.comment) == null ? void 0 : _c.modifierTags) && ((_e = (_d = prop.comment) == null ? void 0 : _d.modifierTags) == null ? void 0 : _e.includes("@internal"))) {
+          meta.push({
+            name: "internal",
+            value: "true"
+          });
+        }
+        const property = {
+          name: prop.name,
+          type: typeof uniformType === "string" ? uniformType : "",
+          description,
+          ...someTypeProps,
+          meta
+        };
+        if (prop.comment) {
+          const examples = commentToUniformExamples(prop.comment);
+          if (examples.length > 0) {
+            property.examples = examples;
+          }
+        }
+        propertiesDef.properties.push(property);
+      }
+      definitions.push(propertiesDef);
+    }
+  }
+  {
+    const methods = ((_f = dec.children) == null ? void 0 : _f.filter(
+      (child) => child.kind === import_typedoc.ReflectionKind.Method
+    )) || [];
+    if (methods.length > 0) {
+      const methodsDef = {
+        title: "Methods",
+        properties: []
+      };
+      for (const method of methods) {
+        if (!((_g = method.signatures) == null ? void 0 : _g[0])) continue;
+        const methodSign = method.signatures[0];
+        let methodDesc = "";
+        if (methodSign.comment) {
+          methodDesc = commentToUniformDescription(methodSign.comment);
+        }
+        let type = "";
+        let someTypeProps = {};
+        if (methodSign.type) {
+          if (typeof methodSign.type === "object") {
+            someTypeProps = methodSign.type;
+          }
+          type = typeof methodSign.type === "string" ? methodSign.type : "";
+        } else {
+          type = "void";
+        }
+        const property = {
+          name: method.name,
+          type,
+          description: methodDesc,
+          ...someTypeProps
+        };
+        if (method.comment) {
+          const examples = commentToUniformExamples(method.comment);
+          if (examples.length > 0) {
+            property.examples = examples;
+          }
+        }
+        methodsDef.properties.push(property);
+      }
+      definitions.push(methodsDef);
+    }
+  }
+  return ref;
+}
+function jsTypeAliasToUniformRef(dec) {
+  var _a, _b;
+  const definitions = [];
+  const ref = {
+    title: `Type ${dec.name}`,
+    canonical: "",
+    description: "",
+    context: void 0,
+    examples: {
+      groups: []
+    },
+    definitions
+  };
+  const declarationCtx = declarationUniformContext.call(this, dec);
+  if (declarationCtx) {
+    ref.context = {
+      ...ref.context,
+      ...declarationCtx
+    };
+  }
+  ref.canonical = uniformCanonical(dec, declarationCtx);
+  if (dec.comment) {
+    const description = commentToUniformDescription(dec.comment);
+    const group = uniformGroup(declarationCtx);
+    if (ref.context) {
+      ref.context.group = [
+        ...group,
+        "Types"
+      ];
+    }
+    ref.description = description;
+  }
+  if (dec.type && ((_a = dec.children) == null ? void 0 : _a.length)) {
+    console.warn("(jsTypeAliasToUniformRef): Type alias with children is not fully supported, only type definition will be handled", dec.name);
+  }
+  {
+    const typeDef = {
+      title: "Type Definition",
+      properties: []
+    };
+    let comment = "";
+    if (dec.comment) {
+      comment = commentToUniformDescription(dec.comment);
+    }
+    if (dec.type) {
+      const uniformType = someTypeToUniform.call(this, dec.type);
+      let someTypeProps = {};
+      if (typeof uniformType === "object") {
+        delete uniformType.ofType;
+        someTypeProps = uniformType;
+      }
+      const propDefinition = {
+        name: "",
+        type: typeof uniformType === "string" ? uniformType : "",
+        description: comment,
+        ...someTypeProps
+      };
+      typeDef.rootProperty = propDefinition;
+    } else if ((_b = dec == null ? void 0 : dec.children) == null ? void 0 : _b.length) {
+      const properties = uniformProperties.call(this, dec);
+      typeDef.properties = properties;
+    }
+    definitions.push(typeDef);
+  }
+  return ref;
+}
+function jsEnumToUniformRef(dec) {
+  var _a;
+  const definitions = [];
+  const ref = {
+    title: `Enum ${dec.name}`,
+    canonical: "",
+    description: "",
+    context: void 0,
+    examples: {
+      groups: []
+    },
+    definitions
+  };
+  const declarationCtx = declarationUniformContext.call(this, dec);
+  if (declarationCtx) {
+    ref.context = {
+      ...ref.context,
+      ...declarationCtx
+    };
+  }
+  ref.canonical = uniformCanonical(dec, declarationCtx);
+  if (dec.comment) {
+    const description = commentToUniformDescription(dec.comment);
+    const group = uniformGroup(declarationCtx);
+    if (ref.context) {
+      ref.context.group = [
+        ...group,
+        "Enums"
+      ];
+    }
+    ref.description = description;
+  }
+  {
+    const members = ((_a = dec.children) == null ? void 0 : _a.filter(
+      (child) => child.kind === import_typedoc.ReflectionKind.EnumMember
+    )) || [];
+    if (members.length > 0) {
+      const membersDef = {
+        title: "Members",
+        properties: []
+      };
+      const sortedMembers = [...members].sort((a, b) => {
+        var _a2, _b, _c, _d;
+        if (!((_b = (_a2 = a.sources) == null ? void 0 : _a2[0]) == null ? void 0 : _b.line) || !((_d = (_c = b.sources) == null ? void 0 : _c[0]) == null ? void 0 : _d.line)) {
+          return 0;
+        }
+        return a.sources[0].line - b.sources[0].line;
+      });
+      for (const member of sortedMembers) {
+        let description = "";
+        if (member.comment) {
+          description = commentToUniformDescription(member.comment);
+        }
+        let value = "";
+        let type = "number";
+        if (member.type && typeof member.type === "object" && member.type.type === "literal" && member.type.value !== null) {
+          if (typeof member.type.value === "string") {
+            value = member.type.value;
+            type = "string";
+          } else {
+            value = member.type.value.toString();
+            type = "number";
+          }
+        } else if (member.defaultValue !== void 0) {
+          value = member.defaultValue.toString();
+          if (value.startsWith('"') && value.endsWith('"')) {
+            type = "string";
+            value = value.substring(1, value.length - 1);
+          }
+        }
+        const formattedName = `${member.name} (${value})`;
+        membersDef.properties.push({
+          name: formattedName,
+          type,
+          description
+        });
+      }
+      definitions.push(membersDef);
+    }
+  }
+  return ref;
+}
+function declarationUniformContext(dec) {
+  var _a, _b, _c, _d;
+  if (!dec.sources || !dec.sources.length) {
+    return;
+  }
+  if (dec.sources.length > 1) {
+    console.warn("(declarationUniformContext): Multiple sources not supported for function declaration", dec.name);
+  }
+  const source = dec.sources[0];
+  const signTxt = this.signatureTextLoader.signatureText(
+    dec.id,
+    source == null ? void 0 : source.line
+  ) || "";
+  const sourceCode = this.signatureTextLoader.signatureSourceCode(
+    dec.id,
+    source == null ? void 0 : source.line
+  ) || "";
+  const symbolMap = this.project.symbolIdMap[dec.id];
+  const fileFullPath = symbolMap.packagePath;
+  const meta = [];
+  if (Array.isArray((_a = dec.comment) == null ? void 0 : _a.modifierTags) && ((_c = (_b = dec.comment) == null ? void 0 : _b.modifierTags) == null ? void 0 : _c.includes("@internal"))) {
+    meta.push({
+      name: "internal",
+      value: "true"
+    });
+  }
+  const ctx = {
+    symbolId: (_d = dec.id) == null ? void 0 : _d.toString(),
+    symbolName: dec.name,
+    symbolKind: dec.kind,
+    packageName: symbolMap == null ? void 0 : symbolMap.packageName,
+    fileName: source.fileName,
+    fileFullPath,
+    line: source.line,
+    col: source.character,
+    signatureText: {
+      code: signTxt,
+      lang: "ts"
+    },
+    sourcecode: {
+      code: sourceCode,
+      lang: "ts"
+    },
+    meta
+  };
+  const category = uniformCategory(dec);
+  if (category) {
+    ctx.category = category;
+  }
+  return ctx;
+}
+function someTypeToUniform(someType) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+  const meta = [];
+  if ("target" in someType) {
+    for (const child of ((_a = this == null ? void 0 : this.project) == null ? void 0 : _a.children) || []) {
+      if (String(child.id) === String(someType.target)) {
+        if (Array.isArray((_b = child.comment) == null ? void 0 : _b.modifierTags) && ((_d = (_c = child.comment) == null ? void 0 : _c.modifierTags) == null ? void 0 : _d.includes("@internal"))) {
+          meta.push({
+            name: "internal",
+            value: "true"
+          });
+        }
+      }
+    }
+  }
+  switch (someType.type) {
+    case "reference": {
+      let refType = `${someType.qualifiedName || someType.name}`;
+      if ("target" in someType && typeof someType.target === "number") {
+        return {
+          type: refType,
+          symbolDef: {
+            id: (_e = someType.target) == null ? void 0 : _e.toString()
+          },
+          meta
+        };
+      }
+      if ("typeArguments" in someType && someType.typeArguments) {
+        const typeArgs = someType.typeArguments.map((arg) => {
+          const argType = someTypeToUniform.call(this, arg);
+          return typeof argType === "string" ? argType : argType.type || "";
+        });
+        refType = `${refType}<${typeArgs.join(", ")}>`;
+      }
+      return refType;
+    }
+    case "union": {
+      const resp = unionLikeSomeType.call(this, someType.types);
+      if (typeof resp === "string") {
+        return resp;
+      }
+      return {
+        ...resp,
+        meta: [
+          ...resp.meta || [],
+          ...meta
+        ]
+      };
+    }
+    case "literal": {
+      if (typeof someType.value === "string") {
+        return `"${someType.value}"`;
+      }
+      return (someType.value || "").toString();
+    }
+    case "reflection": {
+      const properties = uniformProperties.call(this, someType.declaration);
+      let type = "";
+      if (((_f = someType.declaration.indexSignatures) == null ? void 0 : _f.length) || ((_g = someType.declaration.children) == null ? void 0 : _g.length)) {
+        type = this.signatureTextLoader.signatureText(
+          someType.declaration.id,
+          ((_i = (_h = someType.declaration.sources) == null ? void 0 : _h[0]) == null ? void 0 : _i.line) || 0,
+          {
+            typeOnly: true
+          }
+        ) || "";
+      }
+      if ((_j = someType.declaration.indexSignatures) == null ? void 0 : _j.length) {
+        if (properties.length > 1) {
+          console.warn("(someTypeToUniform): Reflection type with multiple properties, using first one as ofProperty", someType.declaration.name);
+        }
+        return {
+          type: import_uniform.DEFINED_DEFINITION_PROPERTY_TYPE.UNION,
+          properties: [],
+          meta,
+          ofProperty: {
+            name: "",
+            type,
+            description: ""
+          }
+        };
+      }
+      return {
+        type,
+        properties,
+        meta
+      };
+    }
+    case "array": {
+      const arrayItemType = someTypeToUniform.call(this, someType.elementType);
+      if (typeof arrayItemType === "string") {
+        return {
+          type: arrayItemType + "[]",
+          meta
+        };
+      }
+      return {
+        ofType: (arrayItemType.type || "") + "[]",
+        type: import_uniform.DEFINED_DEFINITION_PROPERTY_TYPE.ARRAY,
+        ofProperty: {
+          name: "",
+          description: "",
+          type: arrayItemType.type || "",
+          properties: [],
+          symbolDef: arrayItemType.symbolDef
+        },
+        meta
+      };
+    }
+    case "tuple": {
+      const elements = someType.elements || [];
+      const elementTypes = elements.map((element) => someTypeToUniform.call(this, element));
+      const tupleType = `[${elementTypes.map((t) => typeof t === "string" ? t : t.type || "").join(", ")}]`;
+      const symbolIds = [];
+      for (const t of elementTypes) {
+        if (typeof t === "object" && ((_k = t.symbolDef) == null ? void 0 : _k.id)) {
+          if (Array.isArray(t.symbolDef.id)) {
+            symbolIds.push(...t.symbolDef.id);
+          } else {
+            symbolIds.push(t.symbolDef.id);
+          }
+        }
+      }
+      return {
+        type: tupleType,
+        symbolDef: symbolIds.length > 0 ? { id: symbolIds } : void 0,
+        meta
+      };
+    }
+    case "intersection": {
+      const resp = unionLikeSomeType.call(this, someType.types);
+      if (typeof resp === "string") {
+        return resp;
+      }
+      return {
+        ...resp,
+        meta: [
+          ...resp.meta || [],
+          ...meta
+        ]
+      };
+    }
+    case "rest": {
+      const resp = someTypeToUniform.call(this, someType.elementType);
+      if (typeof resp === "string") {
+        return `${resp}[]`;
+      }
+      return {
+        ...resp,
+        type: `${resp.type || ""}[]`
+      };
+    }
+    default: {
+      if (!("name" in someType)) {
+        console.warn("SomeType does not have name property", someType.type);
+        return "";
+      }
+      return someType.name;
+    }
+  }
+  return "";
+}
+function unionLikeSomeType(someTypes) {
+  var _a, _b, _c, _d, _e, _f;
+  let types = [];
+  const symbolIds = [];
+  for (const t of someTypes) {
+    const tUniform = someTypeToUniform.call(this, t);
+    if (typeof tUniform === "object") {
+      if ((_a = tUniform.meta) == null ? void 0 : _a.some((m) => m.name === "internal" && m.value === "true")) {
+        continue;
+      }
+      if (((_b = tUniform.type) == null ? void 0 : _b.startsWith("[")) && ((_c = tUniform.type) == null ? void 0 : _c.endsWith("]"))) {
+        types.push(tUniform.type);
+      } else {
+        types.push(tUniform.ofType || tUniform.type || "");
+      }
+      if ((_d = tUniform == null ? void 0 : tUniform.symbolDef) == null ? void 0 : _d.id) {
+        if (Array.isArray((_e = tUniform == null ? void 0 : tUniform.symbolDef) == null ? void 0 : _e.id)) {
+          symbolIds.push(...(_f = tUniform.symbolDef) == null ? void 0 : _f.id);
+        } else {
+          symbolIds.push(tUniform.symbolDef.id);
+        }
+      }
+      delete tUniform.ofType;
+    } else {
+      types.push(tUniform);
+    }
+  }
+  return {
+    type: types.filter(Boolean).join(" | "),
+    symbolDef: {
+      id: symbolIds
+    }
+  };
+}
+function commentToUniformDescription(comment) {
+  let desc = "";
+  for (const summary of (comment == null ? void 0 : comment.summary) || []) {
+    desc += `${summary.text}
+`;
+  }
+  return desc;
+}
+function commentToUniformExamples(comment) {
+  if (!comment.blockTags || !comment.blockTags.length) {
+    return [];
+  }
+  const examples = [];
+  for (const tag of comment.blockTags) {
+    if (tag.tag === "@example") {
+      for (const content of tag.content || []) {
+        if (content.kind === "code") {
+          const code = content.text.replace(/```ts\n|\n```/g, "");
+          examples.push(code);
+        }
+      }
+    }
+  }
+  return examples;
+}
+function uniformCategory(dec) {
+  if (!dec) {
+    return "";
+  }
+  let category = "";
+  for (const signature of dec.signatures || []) {
+    if (signature.comment) {
+      const comment = signature.comment;
+      if (comment.blockTags) {
+        for (const tag of comment.blockTags) {
+          if (tag.tag === "@category") {
+            for (const content of tag.content || []) {
+              category += content.text;
+            }
+          }
+        }
+      }
+    }
+  }
+  return category;
+}
+function returnCommentToUniform(comment) {
+  if (!comment.blockTags || !comment.blockTags.length) {
+    return "";
+  }
+  let desc = "";
+  for (const tag of comment.blockTags) {
+    if (tag.tag === "@returns") {
+      for (const content of tag.content || []) {
+        desc += `${content.text}
+`;
+      }
+    }
+  }
+  return desc;
+}
+function uniformProperties(dec) {
+  var _a, _b, _c, _d;
+  const properties = [];
+  for (const prop of dec.children || []) {
+    if (!prop.type) {
+      console.warn("(uniformProperties): Property type not found", prop.name);
+      continue;
+    }
+    let description = "";
+    if (prop.comment) {
+      description = commentToUniformDescription(prop.comment);
+    }
+    const uniformType = someTypeToUniform.call(this, prop.type);
+    let meta = [];
+    let someTypeProps = {};
+    if (typeof uniformType === "object") {
+      delete uniformType.ofType;
+      someTypeProps = uniformType;
+      meta = uniformType.meta || [];
+    }
+    if (!((_a = prop.flags) == null ? void 0 : _a.isOptional)) {
+      meta.push({
+        name: "required",
+        value: "true"
+      });
+    }
+    if (Array.isArray((_b = prop.comment) == null ? void 0 : _b.modifierTags) && ((_d = (_c = prop.comment) == null ? void 0 : _c.modifierTags) == null ? void 0 : _d.includes("@internal"))) {
+      meta.push({
+        name: "internal",
+        value: "true"
+      });
+    }
+    const property = {
+      name: prop.name,
+      type: typeof uniformType === "string" ? uniformType : "",
+      description,
+      ...someTypeProps,
+      meta
+    };
+    if (prop.comment) {
+      const examples = commentToUniformExamples(prop.comment);
+      if (examples.length > 0) {
+        property.examples = examples;
+      }
+    }
+    properties.push(property);
+  }
+  return properties;
+}
+function uniformGroup(ctx) {
+  if (!ctx) {
+    return [];
+  }
+  const group = ctx.packageName.split("/");
+  return group;
+}
+function uniformCanonical(dec, ctx) {
+  const parts = [];
+  if (ctx == null ? void 0 : ctx.packageName) {
+    parts.push(ctx.packageName);
+  }
+  switch (dec.kind) {
+    case import_typedoc.ReflectionKind.Class: {
+      parts.push("classes", dec.name);
+      break;
+    }
+    case import_typedoc.ReflectionKind.Interface: {
+      parts.push("interfaces", dec.name);
+      break;
+    }
+    case import_typedoc.ReflectionKind.Function: {
+      parts.push("functions", dec.name);
+      break;
+    }
+    case import_typedoc.ReflectionKind.TypeAlias: {
+      parts.push("types", dec.name);
+      break;
+    }
+    case import_typedoc.ReflectionKind.Enum: {
+      parts.push("enums", dec.name);
+      break;
+    }
+    default: {
+      return "";
+    }
+  }
+  return parts.join("/");
+}
+
+// packages/ts/uniformToMiniUniform.ts
+var import_uniform2 = require("@xyd-js/uniform");
+var TXT = {
+  Properties: "Properties"
+};
+var PRIMITIVE_TYPES = /* @__PURE__ */ new Set(["string", "number", "boolean"]);
+function uniformToMiniUniform(rootSymbolName, references) {
+  var _a, _b;
+  const output = [];
+  const refBySymbolId = {};
+  for (const reference of references) {
+    const ctx = reference.context;
+    if (ctx == null ? void 0 : ctx.symbolId) {
+      if ((_b = (_a = reference.context) == null ? void 0 : _a.meta) == null ? void 0 : _b.some((m) => m.name === "internal" && m.value === "true")) {
+        continue;
+      }
+      refBySymbolId[ctx.symbolId] = JSON.parse(JSON.stringify(reference));
+    }
+  }
+  for (const reference of references) {
+    const ctx = reference.context;
+    if ((ctx == null ? void 0 : ctx.symbolName) !== rootSymbolName) {
+      continue;
+    }
+    const miniRef = {
+      ...reference,
+      title: (ctx == null ? void 0 : ctx.symbolName) || reference.title,
+      canonical: "",
+      context: ctx,
+      definitions: []
+    };
+    for (const def of reference.definitions) {
+      const miniDef = {
+        ...def,
+        title: TXT.Properties,
+        properties: [],
+        symbolDef: {
+          ...def.symbolDef || {},
+          canonical: ""
+          // TODO: support canonical in the future
+        }
+      };
+      const defProperties = (def == null ? void 0 : def.rootProperty) ? [def.rootProperty] : def.properties || [];
+      definitionMiniPropsPassThrough(
+        refBySymbolId,
+        defProperties,
+        miniDef
+      );
+      miniRef.definitions.push(miniDef);
+    }
+    output.push(miniRef);
+  }
+  return output;
+}
+function definitionMiniPropsPassThrough(refBySymbolId, defProperties, miniDef, options) {
+  for (let property of defProperties) {
+    property = {
+      ...property,
+      symbolDef: {
+        ...property.symbolDef || {},
+        canonical: ""
+        // TODO: support canonical in the future
+      }
+    };
+    const resolvedProperty = resolveProperty(refBySymbolId, property, options);
+    miniDef.properties.push({
+      ...resolvedProperty,
+      symbolDef: {
+        ...resolvedProperty.symbolDef || {},
+        canonical: ""
+        // TODO: support canonical in the future
+      }
+    });
+  }
+}
+function resolveProperty(refBySymbolId, property, options) {
+  var _a, _b, _c;
+  property = {
+    ...property,
+    symbolDef: {
+      ...property.symbolDef || {},
+      canonical: ""
+      // TODO: support canonical in the future
+    }
+  };
+  const depth = (options == null ? void 0 : options.depth) || 0;
+  const visited = (options == null ? void 0 : options.visited) || /* @__PURE__ */ new Set();
+  if (depth > 10) {
+    console.warn("Maximum recursion depth reached for property:", property.name);
+    return property;
+  }
+  if ((_a = property == null ? void 0 : property.properties) == null ? void 0 : _a.length) {
+    return property;
+  }
+  const resolvedPropertyProps = [];
+  const resolvedProperty = {
+    ...property,
+    properties: resolvedPropertyProps
+  };
+  if (property.type === import_uniform2.DEFINED_DEFINITION_PROPERTY_TYPE.ARRAY) {
+    if (property.ofProperty) {
+      const resolvedRootProperty = resolveProperty(
+        refBySymbolId,
+        property.ofProperty,
+        options
+      );
+      resolvedProperty.ofProperty = resolvedRootProperty;
+      return resolvedProperty;
+    } else {
+      console.warn(`Property ${property.name} is an array but has no ofProperty defined, using type only`);
+    }
+    return property;
+  }
+  const symbolId = (_b = property == null ? void 0 : property.symbolDef) == null ? void 0 : _b.id;
+  if (symbolId) {
+    if (typeof symbolId === "string") {
+      if (visited.has(symbolId)) {
+        return resolvedProperty;
+      }
+      visited.add(symbolId);
+      const refSymbol = refBySymbolId[symbolId];
+      const refSymbolDefinition = (_c = refSymbol == null ? void 0 : refSymbol.definitions) == null ? void 0 : _c[0];
+      const refSymbolDefinitionProps = (refSymbolDefinition == null ? void 0 : refSymbolDefinition.properties) || [];
+      if (!refSymbol) {
+        console.warn(`Reference for symbol ${symbolId} not found, using type only`);
+        return resolvedProperty;
+      }
+      if (refSymbolDefinitionProps.length) {
+        for (const prop of refSymbolDefinitionProps) {
+          const resolvedProp = resolveProperty(refBySymbolId, prop, {
+            ...options,
+            depth: depth + 1,
+            visited: new Set(visited)
+          });
+          resolvedPropertyProps.push(resolvedProp);
+        }
+      } else if (refSymbolDefinition.rootProperty) {
+        const resolvedProp = resolveProperty(refBySymbolId, refSymbolDefinition.rootProperty, {
+          ...options,
+          depth: depth + 1,
+          visited: new Set(visited)
+        });
+        resolvedProperty.ofProperty = resolvedProp;
+      } else {
+        console.warn(`Reference for symbol ${symbolId} has no properties, using type and description only`);
+      }
+      if (!resolvedProperty.description) {
+        resolvedProperty.description = refSymbol.description || "";
+      }
+      return resolvedProperty;
+    }
+    const isResolveUnion = isResolveUnionRef(property);
+    if (isResolveUnion) {
+      resolvedProperty.type = import_uniform2.DEFINED_DEFINITION_PROPERTY_TYPE.UNION;
+      const unionProps = handleUnionTypes(
+        refBySymbolId,
+        property,
+        options
+      );
+      if (unionProps.length > 1) {
+        resolvedProperty.properties = unionProps;
+      } else {
+        resolvedProperty.ofProperty = unionProps[0];
+      }
+      const shortType = shortMergedType(resolvedProperty);
+      if (shortType) {
+        return shortType;
+      }
+      return resolvedProperty;
+    }
+  }
+  return property;
+}
+function shortMergedType(property) {
+  property = {
+    ...property,
+    symbolDef: {
+      ...property.symbolDef || {},
+      canonical: ""
+      // TODO: support canonical in the future
+    }
+  };
+  if (property.type !== import_uniform2.DEFINED_DEFINITION_PROPERTY_TYPE.UNION) {
+    return null;
+  }
+  const properties = property.ofProperty ? [property.ofProperty] : property.properties || [];
+  const processedProperties = properties.map((prop) => {
+    if (prop.type === import_uniform2.DEFINED_DEFINITION_PROPERTY_TYPE.UNION) {
+      const shortType2 = shortMergedType(prop);
+      if (shortType2) {
+        return shortType2;
+      }
+    }
+    const shortType = shortMergedType({
+      name: "",
+      description: "",
+      type: import_uniform2.DEFINED_DEFINITION_PROPERTY_TYPE.UNION,
+      properties: prop.properties,
+      ofProperty: prop.ofProperty
+    });
+    if (shortType) {
+      return shortType;
+    }
+    return prop;
+  });
+  if (!(processedProperties == null ? void 0 : processedProperties.length)) {
+    return null;
+  }
+  const hasOnlySimpleTypes = processedProperties.every((prop) => {
+    if (isLiteralValues(prop.type)) {
+      return true;
+    }
+    return PRIMITIVE_TYPES.has(prop.type);
+  });
+  if (!hasOnlySimpleTypes) {
+    return null;
+  }
+  const types = processedProperties.map((prop) => prop.type);
+  const mergedType = types.join(" | ");
+  return {
+    ...property,
+    type: mergedType,
+    properties: []
+  };
+}
+function handleUnionTypes(refBySymbolId, property, options) {
+  var _a, _b, _c, _d;
+  property = {
+    ...property,
+    symbolDef: {
+      ...property.symbolDef || {},
+      canonical: ""
+      // TODO: support canonical in the future
+    }
+  };
+  const symbolIds = Array.isArray((_a = property.symbolDef) == null ? void 0 : _a.id) ? property.symbolDef.id : [];
+  const typeString = property.type;
+  const properties = [];
+  const unionTypeStringsMap = (typeString || "").split("|").map((t) => t.trim()).reduce((acc, type) => ({
+    ...acc,
+    [type]: true
+  }), {});
+  if (symbolIds.length > 0) {
+    for (const symbolId of symbolIds) {
+      const refSymbol = refBySymbolId[symbolId];
+      const refSymbolDefinition = (_b = refSymbol == null ? void 0 : refSymbol.definitions) == null ? void 0 : _b[0];
+      const ctx = refSymbol == null ? void 0 : refSymbol.context;
+      if (refSymbolDefinition) {
+        unionTypeStringsMap[ctx.symbolName] = false;
+        const propProperties = [];
+        const prop = {
+          name: ctx.symbolName || "",
+          type: ctx.symbolName || "",
+          description: refSymbol.description || "",
+          properties: propProperties,
+          symbolDef: {
+            id: symbolId,
+            canonical: ""
+            // TODO: support canonical in the future
+          }
+        };
+        if (refSymbolDefinition.properties.length) {
+          for (const prop2 of refSymbolDefinition.properties) {
+            const resolvedProp = resolveProperty(
+              refBySymbolId,
+              prop2,
+              options
+            );
+            propProperties.push(resolvedProp);
+          }
+        } else if (refSymbolDefinition.rootProperty) {
+          const resolvedProp = resolveProperty(
+            refBySymbolId,
+            refSymbolDefinition.rootProperty,
+            options
+          );
+          const shouldMergeUnion = resolvedProp.type === import_uniform2.DEFINED_DEFINITION_PROPERTY_TYPE.UNION && ((_c = resolvedProp.ofProperty) == null ? void 0 : _c.type) && !((_d = resolvedProp.properties) == null ? void 0 : _d.length);
+          if (shouldMergeUnion) {
+            prop.ofProperty = resolvedProp.ofProperty;
+          } else {
+            prop.ofProperty = resolvedProp;
+          }
+        }
+        properties.push(prop);
+        if (!prop.description) {
+          prop.description = refSymbol.description || "";
+        }
+      }
+    }
+  }
+  for (const type of Object.keys(unionTypeStringsMap)) {
+    const ok = unionTypeStringsMap[type];
+    if (!ok) {
+      continue;
+    }
+    properties.push({
+      name: type,
+      type,
+      description: "",
+      properties: []
+    });
+  }
+  return properties;
+}
+function isResolveUnionRef(property) {
+  var _a;
+  const symbolId = (_a = property == null ? void 0 : property.symbolDef) == null ? void 0 : _a.id;
+  const symbolIsArr = Array.isArray(symbolId) && symbolId.length;
+  if (symbolIsArr) {
+    return true;
+  }
+  const hasUnionString = property.type && property.type.includes("|");
+  if (hasUnionString) {
+    const literalValues = isLiteralValues(property.type);
+    if (literalValues) {
+      return false;
+    }
+    return true;
+  }
+  return false;
+}
+function isLiteralValues(type) {
+  const types = type.split("|").map((t) => t.trim());
+  return types.every(
+    (t) => t.startsWith('"') && t.endsWith('"') || t.startsWith("'") && t.endsWith("'")
+  );
+}
+
+// packages/ts/index.ts
+var importedFiles = /* @__PURE__ */ new Set();
+async function sourcesToUniformV2(root, entryPoints) {
+  var _a;
+  const commonOptions = {
+    // entryPoints,
+    // entryPointStrategy: TypeDoc.EntryPointStrategy.Packages,
+    exclude: ["**/*.test.ts", "**/*.test.tsx"],
+    // @ts-ignore // TODO: for some reason on build types mismatch
+    excludePrivate: true,
+    // @ts-ignore
+    excludeProtected: true,
+    // @ts-ignore
+    excludeExternals: true,
+    // @ts-ignore
+    includeVersion: true,
+    // @ts-ignore
+    // hideGenerator: true,
+    // @ts-ignore
+    skipErrorChecking: true,
+    // @ts-ignore
+    sort: ["source-order"],
+    // @ts-ignore
+    sortEntryPoints: false
+  };
+  const options = {
+    ...commonOptions
+  };
+  const everySingleFile = entryPoints == null ? void 0 : entryPoints.every((ep) => !!path2.extname(ep));
+  if (everySingleFile) {
+    entryPoints.map((ep) => {
+      findImports(root, path2.resolve(root, ep));
+    });
+    const fileImported = Array.from(importedFiles) || [];
+    options.entryPoints = [
+      ...(_a = [
+        ...entryPoints,
+        ...fileImported
+      ]) == null ? void 0 : _a.map((ep) => path2.resolve(root, ep))
+    ];
+  } else {
+    options.entryPointStrategy = TypeDoc.EntryPointStrategy.Packages;
+    options.entryPoints = entryPoints;
+    options.packageOptions = {
+      ...commonOptions
+    };
+  }
+  const app = await TypeDoc.Application.bootstrapWithPlugins(options);
+  const project = await app.convert();
+  if (!project) {
+    console.error("Failed to generate documentation.");
+    return;
+  }
+  const jsonOutput = await app.serializer.projectToObject(project, root);
+  const projectJson = jsonOutput;
+  if (!projectJson.schemaVersion || !projectJson.children || !projectJson.children.length) {
+    console.error("Failed to generate documentation.");
+    return;
+  }
+  const references = typedocToUniform(root, projectJson);
+  if (!references) {
+    console.error("Failed to generate documentation.");
+    return;
+  }
+  return {
+    references,
+    projectJson
+  };
+}
+function findImports(root, file, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(file)) return;
+  seen.add(file);
+  const source = import_typescript.default.createSourceFile(
+    file,
+    import_typescript.default.sys.readFile(file) || "",
+    import_typescript.default.ScriptTarget.Latest,
+    true
+  );
+  for (const stmt of source.statements) {
+    if (import_typescript.default.isImportDeclaration(stmt) && stmt.moduleSpecifier) {
+      const importPath = stmt.moduleSpecifier.getText().replace(/['"]/g, "");
+      if (importPath.startsWith(".")) {
+        const resolved = (0, import_path.resolve)(file, "..", importPath + ".ts");
+        const relativePath = path2.relative(root, resolved);
+        importedFiles.add(relativePath);
+        findImports(root, resolved, seen);
+      }
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sourcesToUniformV2,
+  uniformToMiniUniform
+});
+//# sourceMappingURL=ts.cjs.map