@openpkg-ts/doc-generator 0.1.0 → 0.1.2

package/dist/shared/{chunk-7hg53zpt.js → server-83s9r625.js}

@@ -1,12 +1,172 @@
-import {
-  buildSignatureString,
-  formatParameters,
-  formatReturnType,
-  formatSchema,
-  getMethods,
-  getProperties,
-  sortByName
-} from "./chunk-taeg9090.js";
+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);
+  });
+}
 
 // src/render/html.ts
 var defaultCSS = `
@@ -323,14 +483,14 @@ function simplifySignature(sig) {
   };
 }
 function simplifyMember(member) {
-  const isMethod = !!member.signatures?.length;
+  const isMethod2 = !!member.signatures?.length;
   return {
     name: member.name || "",
-    kind: isMethod ? "method" : "property",
-    type: isMethod ? undefined : formatSchema(member.schema),
+    kind: isMethod2 ? "method" : "property",
+    type: isMethod2 ? undefined : formatSchema(member.schema),
     description: member.description,
     visibility: member.visibility || "public",
-    signature: isMethod ? simplifySignature(member.signatures?.[0]) : undefined
+    signature: isMethod2 ? simplifySignature(member.signatures?.[0]) : undefined
   };
 }
 function simplifyExample(example) {
@@ -1157,4 +1317,4 @@ function extractModuleName(exp) {
   return;
 }
 
-export { toHTML, toJSON, toJSONString, exportToMarkdown, toMarkdown, toNavigation, toFumadocsMetaJSON, toDocusaurusSidebarJS, toSearchIndex, toPagefindRecords, toAlgoliaRecords, toSearchIndexJSON, loadSpec, createDocs };
+export { __toESM, __require, formatSchema, formatTypeParameters, formatParameters, formatReturnType, buildSignatureString, resolveTypeRef, isMethod, isProperty, getMethods, getProperties, groupByVisibility, sortByName, sortByKindThenName, toHTML, toJSON, toJSONString, exportToMarkdown, toMarkdown, toNavigation, toFumadocsMetaJSON, toDocusaurusSidebarJS, toSearchIndex, toPagefindRecords, toAlgoliaRecords, toSearchIndexJSON, loadSpec, createDocs };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpkg-ts/doc-generator",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "API doc generator consuming OpenPkg specs. TypeDoc alternative for modern doc frameworks.",
   "keywords": [
     "openpkg",
@@ -55,7 +55,7 @@
     "test:watch": "bun test --watch"
   },
   "dependencies": {
-    "@openpkg-ts/spec": "workspace:*",
+    "@openpkg-ts/spec": "^0.11.1",
     "commander": "^14.0.0"
   },
   "peerDependencies": {