@openpkg-ts/doc-generator 0.1.1 → 0.1.2

package/dist/shared/chunk-taeg9090.js

@@ -1,171 +0,0 @@
-import { createRequire } from "node:module";
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-// src/core/query.ts
-function formatSchema(schema) {
-  if (!schema)
-    return "unknown";
-  if (typeof schema === "string")
-    return schema;
-  if (typeof schema === "object" && schema !== null) {
-    if ("$ref" in schema && typeof schema.$ref === "string") {
-      return schema.$ref.replace("#/types/", "");
-    }
-    if ("anyOf" in schema && Array.isArray(schema.anyOf)) {
-      return schema.anyOf.map((s) => formatSchema(s)).join(" | ");
-    }
-    if ("allOf" in schema && Array.isArray(schema.allOf)) {
-      return schema.allOf.map((s) => formatSchema(s)).join(" & ");
-    }
-    if ("type" in schema && schema.type === "array") {
-      const items = "items" in schema ? formatSchema(schema.items) : "unknown";
-      return `${items}[]`;
-    }
-    if ("type" in schema && schema.type === "tuple" && "items" in schema) {
-      const items = schema.items.map(formatSchema).join(", ");
-      return `[${items}]`;
-    }
-    if ("type" in schema && schema.type === "object") {
-      if ("properties" in schema && schema.properties) {
-        const props = Object.entries(schema.properties).map(([k, v]) => `${k}: ${formatSchema(v)}`).join("; ");
-        return `{ ${props} }`;
-      }
-      return "object";
-    }
-    if ("type" in schema && typeof schema.type === "string") {
-      return schema.type;
-    }
-  }
-  return "unknown";
-}
-function formatTypeParameters(typeParams) {
-  if (!typeParams?.length)
-    return "";
-  const params = typeParams.map((tp) => {
-    let str = tp.name;
-    if (tp.constraint)
-      str += ` extends ${tp.constraint}`;
-    if (tp.default)
-      str += ` = ${tp.default}`;
-    return str;
-  });
-  return `<${params.join(", ")}>`;
-}
-function formatParameters(sig) {
-  if (!sig?.parameters?.length)
-    return "()";
-  const params = sig.parameters.map((p) => {
-    const optional = p.required === false ? "?" : "";
-    const rest = p.rest ? "..." : "";
-    const type = formatSchema(p.schema);
-    return `${rest}${p.name}${optional}: ${type}`;
-  });
-  return `(${params.join(", ")})`;
-}
-function formatReturnType(sig) {
-  if (!sig?.returns)
-    return "void";
-  return formatSchema(sig.returns.schema);
-}
-function buildSignatureString(exp, sigIndex = 0) {
-  const sig = exp.signatures?.[sigIndex];
-  const typeParams = formatTypeParameters(exp.typeParameters || sig?.typeParameters);
-  switch (exp.kind) {
-    case "function": {
-      const params = formatParameters(sig);
-      const returnType = formatReturnType(sig);
-      return `function ${exp.name}${typeParams}${params}: ${returnType}`;
-    }
-    case "class": {
-      const ext = exp.extends ? ` extends ${exp.extends}` : "";
-      const impl = exp.implements?.length ? ` implements ${exp.implements.join(", ")}` : "";
-      return `class ${exp.name}${typeParams}${ext}${impl}`;
-    }
-    case "interface": {
-      const ext = exp.extends ? ` extends ${exp.extends}` : "";
-      return `interface ${exp.name}${typeParams}${ext}`;
-    }
-    case "type": {
-      const typeValue = typeof exp.type === "string" ? exp.type : formatSchema(exp.schema);
-      return `type ${exp.name}${typeParams} = ${typeValue}`;
-    }
-    case "enum": {
-      return `enum ${exp.name}`;
-    }
-    case "variable": {
-      const typeValue = typeof exp.type === "string" ? exp.type : formatSchema(exp.schema);
-      return `const ${exp.name}: ${typeValue}`;
-    }
-    default:
-      return exp.name;
-  }
-}
-function resolveTypeRef(ref, spec) {
-  const id = ref.replace("#/types/", "");
-  return spec.types?.find((t) => t.id === id);
-}
-function isMethod(member) {
-  return !!member.signatures?.length;
-}
-function isProperty(member) {
-  return !member.signatures?.length;
-}
-function getMethods(members) {
-  return members?.filter(isMethod) ?? [];
-}
-function getProperties(members) {
-  return members?.filter(isProperty) ?? [];
-}
-function groupByVisibility(members) {
-  const groups = {
-    public: [],
-    protected: [],
-    private: []
-  };
-  for (const member of members ?? []) {
-    const visibility = member.visibility ?? "public";
-    groups[visibility].push(member);
-  }
-  return groups;
-}
-function sortByName(items) {
-  return [...items].sort((a, b) => a.name.localeCompare(b.name));
-}
-function sortByKindThenName(exports) {
-  const kindOrder = {
-    function: 0,
-    class: 1,
-    interface: 2,
-    type: 3,
-    enum: 4,
-    variable: 5,
-    namespace: 6,
-    module: 7,
-    reference: 8,
-    external: 9
-  };
-  return [...exports].sort((a, b) => {
-    const kindDiff = kindOrder[a.kind] - kindOrder[b.kind];
-    if (kindDiff !== 0)
-      return kindDiff;
-    return a.name.localeCompare(b.name);
-  });
-}
-
-export { __toESM, __require, formatSchema, formatTypeParameters, formatParameters, formatReturnType, buildSignatureString, resolveTypeRef, isMethod, isProperty, getMethods, getProperties, groupByVisibility, sortByName, sortByKindThenName };