@scalar/cli 2.0.1 → 2.5.1

package/chunks/action-FIXBOJEW.js

@@ -0,0 +1,244 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  measureTime
+} from "./chunk-KHDYYVYF.js";
+import {
+  isAsyncApiDocument,
+  isDocument
+} from "./chunk-24WAOKGG.js";
+import "./chunk-CISTON3A.js";
+import "./chunk-Q7DOQHZN.js";
+import {
+  isUrl
+} from "./chunk-4ORL4MST.js";
+import {
+  output
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-GSGZHE26.js";
+import "./chunk-IKT5F47M.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/document/split/action.ts
+import fs2 from "node:fs/promises";
+import path2 from "node:path";
+import { text } from "@clack/prompts";
+import as from "ansis";
+import { bundle } from "@scalar/json-magic/bundle";
+import { fetchUrls, readFiles } from "@scalar/json-magic/bundle/plugins/node";
+import {
+  createServerWorkspaceStore,
+  WORKSPACE_FILE_NAME
+} from "@scalar/workspace-store/server";
+
+// src/domains/document/split/split-asyncapi.ts
+import { createHash } from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { extensions } from "@scalar/json-magic/bundle";
+import { escapeJsonPointer } from "@scalar/json-magic/helpers/escape-json-pointer";
+async function splitAsyncApi(document, outputPath) {
+  const chunks = /* @__PURE__ */ new Map();
+  const root = structuredClone(document);
+  const segmentNames = /* @__PURE__ */ new Map();
+  const usedNames = /* @__PURE__ */ new Set();
+  const shorten = (name) => name.length <= 240 ? name : `${name.slice(0, 170)}~5${createHash("sha256").update(name).digest("hex")}`;
+  const getFilePath = (segments) => {
+    const names = [];
+    for (const segment of segments) {
+      const directory = names.join("/");
+      const key = JSON.stringify([directory, segment]);
+      const existing = segmentNames.get(key);
+      if (existing !== void 0) {
+        names.push(existing);
+        continue;
+      }
+      const escaped = shorten(
+        encodeURIComponent(escapeJsonPointer(segment)).replaceAll("%", "~2").replaceAll(".", "~3").replaceAll("*", "~6") || "~7"
+      );
+      const name = shorten(
+        usedNames.has(`${directory}/${escaped}`.toLowerCase()) || /^(con|prn|aux|nul|com[1-9]|lpt[1-9])$/i.test(escaped) ? escaped.replace(
+          /[a-z]/gi,
+          (letter) => `~4${letter.charCodeAt(0).toString(16)}`
+        ) : escaped
+      );
+      segmentNames.set(key, name);
+      usedNames.add(`${directory}/${name}`.toLowerCase());
+      names.push(name);
+    }
+    return `chunks/default/${names.join("/")}.json`;
+  };
+  const extract = (parent, key, segments) => {
+    const pointer = `#/${segments.map(escapeJsonPointer).join("/")}`;
+    const file = getFilePath(segments);
+    chunks.set(pointer, { file, value: parent[key] });
+    parent[key] = {
+      $ref: `#/${segments.map((segment) => encodeURIComponent(escapeJsonPointer(segment))).join("/")}`
+    };
+  };
+  const extractMap = (value, segments) => {
+    if (!isDocument(value)) {
+      return;
+    }
+    for (const key of Object.keys(value)) {
+      extract(value, key, [...segments, key]);
+    }
+  };
+  const resolveChannel = (value, seen = /* @__PURE__ */ new Set()) => {
+    if (!isDocument(value) || typeof value.$ref !== "string" || !value.$ref.startsWith("#/") || seen.has(value.$ref)) {
+      return value;
+    }
+    seen.add(value.$ref);
+    const segments = decodeURIComponent(value.$ref.slice(2)).split("/").map((segment) => segment.replaceAll("~1", "/").replaceAll("~0", "~"));
+    const target = segments.reduce(
+      (node, segment) => isDocument(node) && Object.hasOwn(node, segment) ? node[segment] : void 0,
+      root
+    );
+    const resolved = resolveChannel(target, seen);
+    if (!isDocument(resolved)) {
+      return value;
+    }
+    const { $ref: _ref, ...siblings } = value;
+    return { ...resolved, ...siblings };
+  };
+  if (isDocument(root.channels)) {
+    for (const [name, value] of Object.entries(root.channels)) {
+      const channel = structuredClone(resolveChannel(value));
+      if (!isDocument(channel)) {
+        continue;
+      }
+      root.channels[name] = channel;
+      extractMap(channel.messages, ["channels", name, "messages"]);
+      for (const method of ["publish", "subscribe"]) {
+        if (isDocument(channel[method])) {
+          if (isDocument(channel[method].message)) {
+            extract(channel[method], "message", [
+              "channels",
+              name,
+              method,
+              "message"
+            ]);
+          }
+          extract(channel, method, ["channels", name, method]);
+        }
+      }
+    }
+  }
+  extractMap(root.channels, ["channels"]);
+  extractMap(root.operations, ["operations"]);
+  if (isDocument(root.components)) {
+    for (const [type, entries] of Object.entries(root.components)) {
+      if (!type.startsWith("x-")) {
+        extractMap(entries, ["components", type]);
+      }
+    }
+  }
+  if (isDocument(root[extensions.externalDocuments])) {
+    extractMap(root[extensions.externalDocuments], [
+      extensions.externalDocuments
+    ]);
+    extract(root, extensions.externalDocuments, [extensions.externalDocuments]);
+    delete root[extensions.externalDocuments];
+    delete root[extensions.externalDocumentsMappings];
+  }
+  const pointers = [...chunks.keys()].sort((a, b) => b.length - a.length);
+  const rebase = (value, sourceFile) => {
+    if (Array.isArray(value)) {
+      return value.map((entry) => rebase(entry, sourceFile));
+    }
+    if (!isDocument(value)) {
+      return value;
+    }
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => {
+        if (key !== "$ref" || typeof entry !== "string" || !entry.startsWith("#")) {
+          return [key, rebase(entry, sourceFile)];
+        }
+        const pointer = decodeURIComponent(entry);
+        const target = pointers.find(
+          (candidate) => pointer === candidate || pointer.startsWith(`${candidate}/`)
+        );
+        const targetFile = target && chunks.get(target)?.file || "out.json";
+        const fragment = target ? `#${pointer.slice(target.length)}` : pointer;
+        const relativeFile = path.posix.relative(
+          path.posix.dirname(sourceFile),
+          targetFile
+        );
+        return [
+          key,
+          `${relativeFile.split("/").map(encodeURIComponent).join("/")}#${fragment.slice(1).split("/").map(encodeURIComponent).join("/")}`
+        ];
+      })
+    );
+  };
+  for (const { file, value } of [
+    ...chunks.values(),
+    { file: "out.json", value: root }
+  ]) {
+    const destination = path.join(outputPath, file);
+    await fs.mkdir(path.dirname(destination), { recursive: true });
+    await fs.writeFile(destination, JSON.stringify(rebase(value, file)));
+  }
+}
+
+// src/domains/document/split/action.ts
+async function splitAction(input, { output: __outputPath }) {
+  if (!input) {
+    return output.error().title("Missing input").message("Please provide a file path or URL to split").exit("error");
+  }
+  const getOutputPath = async () => {
+    if (__outputPath !== void 0 && typeof __outputPath === "string") {
+      return __outputPath;
+    }
+    const outputPath2 = await text({
+      message: "Where should the chunks be written?",
+      defaultValue: "./assets",
+      placeholder: "./assets"
+    });
+    if (typeof outputPath2 !== "string") {
+      return output.error().message("Operation cancelled by user").exit("error");
+    }
+    return outputPath2;
+  };
+  const outputPath = await getOutputPath();
+  const document = await bundle(isUrl(input) ? input : path2.resolve(input), {
+    plugins: [readFiles(), fetchUrls()],
+    treeShake: false,
+    hooks: {
+      onResolveError: ({ $ref }) => {
+        throw new Error(`Could not resolve reference: ${$ref}`);
+      }
+    }
+  }).catch(() => null);
+  if (!isDocument(document)) {
+    return output.error().title("Invalid input").message(
+      "Could not read an OpenAPI or AsyncAPI document from the input. Please provide a valid JSON or YAML file."
+    ).exit("error");
+  }
+  const { executionTimeMs } = await measureTime(async () => {
+    if (isAsyncApiDocument(document)) {
+      await splitAsyncApi(document, outputPath);
+      return;
+    }
+    const documentName = "default";
+    const store = await createServerWorkspaceStore({
+      mode: "static",
+      documents: [{ name: documentName, document }],
+      // The workspace writer prefixes its directory with cwd, including absolute paths.
+      directory: path2.relative(process.cwd(), path2.resolve(outputPath)) || "."
+    });
+    await store.generateWorkspaceChunks();
+    const workspaceFilePath = path2.join(outputPath, WORKSPACE_FILE_NAME);
+    const sparseDocument = JSON.parse(
+      await fs2.readFile(workspaceFilePath, { encoding: "utf-8" })
+    );
+    await fs2.writeFile(
+      path2.join(outputPath, "out.json"),
+      JSON.stringify(sparseDocument.documents[documentName])
+    );
+    await fs2.rm(workspaceFilePath);
+  });
+  output.info().line().title(as.green("Document Split Successfully! \u{1F389}")).line().message(`\u2728 Chunks have been generated at: ${as.blue(outputPath)}`).line(`\u23F1\uFE0F Split completed in ${as.yellow(executionTimeMs.toFixed(2))}ms`).line("").print();
+}
+export {
+  splitAction
+};

package/chunks/action-G26LSVZ7.js

@@ -0,0 +1,40 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  getFileOrUrl
+} from "./chunk-24WAOKGG.js";
+import "./chunk-CISTON3A.js";
+import "./chunk-Q7DOQHZN.js";
+import "./chunk-4ORL4MST.js";
+import {
+  output
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-GSGZHE26.js";
+import "./chunk-IKT5F47M.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/document/markdown/action.ts
+import fs from "node:fs";
+import as from "ansis";
+import { createMarkdownFromOpenApi } from "@scalar/openapi-to-markdown";
+async function markdownAction(inputArgument, { output: outputPath }) {
+  const startTime = performance.now();
+  if (!inputArgument) {
+    return output.error().title("Invalid argument").message("Please provide a file path or URL").exit("error");
+  }
+  const specification = await getFileOrUrl(inputArgument);
+  const markdown = await createMarkdownFromOpenApi(specification);
+  if (outputPath) {
+    fs.writeFileSync(outputPath, markdown, "utf8");
+    const endTime = performance.now();
+    output.info().line(
+      `${as.green("Markdown generated")} ${as.grey(
+        `in ${as.white(`${as.bold(`${Math.round(endTime - startTime)}`)} ms`)}`
+      )}`
+    ).line(`Written to ${as.cyan(outputPath)}`).print();
+    return;
+  }
+  process.stdout.write(markdown);
+}
+export {
+  markdownAction
+};

package/chunks/action-H3RTILLM.js

@@ -0,0 +1,46 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  output
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/document/void/action.ts
+import { serve } from "@hono/node-server";
+import as from "ansis";
+import { createVoidServer } from "@scalar/void-server";
+async function voidAction({
+  once,
+  port
+}) {
+  const server = await bootServer({
+    port
+  });
+  if (once) {
+    setTimeout(() => {
+      server.close();
+    }, 2e3);
+  }
+}
+var bootServer = async ({
+  port
+}) => {
+  const app = await createVoidServer();
+  return serve(
+    {
+      fetch: app.fetch,
+      port: port ?? 3e3
+    },
+    (info) => {
+      output.info().line(
+        `${as.green.bold("\u279C Void Server")} ${as.white(
+          "listening on"
+        )} ${as.cyan(`http://localhost:${info.port}`)}
+`
+      ).print();
+    }
+  );
+};
+export {
+  bootServer,
+  voidAction
+};

package/chunks/action-HGBBV353.js

@@ -0,0 +1,86 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  fetchFromRegistry
+} from "./chunk-UGGNHILG.js";
+import "./chunk-COBPBRQF.js";
+import {
+  registry
+} from "./chunk-XCSR4RIT.js";
+import {
+  getAuthData
+} from "./chunk-M37TP6U2.js";
+import "./chunk-4ZDQXWBT.js";
+import "./chunk-VNYE4R7N.js";
+import "./chunk-OQKDBLOZ.js";
+import "./chunk-CISTON3A.js";
+import "./chunk-Q7DOQHZN.js";
+import "./chunk-4ORL4MST.js";
+import {
+  output
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-GSGZHE26.js";
+import {
+  docVersionSchema,
+  external_exports
+} from "./chunk-IKT5F47M.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/registry/get/action.ts
+import fs from "node:fs/promises";
+var versionSchema = external_exports.union([docVersionSchema, external_exports.literal("latest")]);
+async function getAction(namespace, slug, args) {
+  if (!namespace) {
+    output.error().title("Invalid input").message("Please provide namespace of the document").exit("error");
+    return;
+  }
+  if (!slug) {
+    output.error().title("Invalid input").message("Please provide slug of the document").exit("error");
+    return;
+  }
+  const result = external_exports.object({
+    version: versionSchema,
+    format: external_exports.enum(["json", "yaml"]),
+    output: external_exports.string().min(1).optional()
+  }).safeParse({
+    version: args.version ?? "latest",
+    format: args.format,
+    output: args.output
+  });
+  if (result.error) {
+    output.error().title("Invalid input").message(result.error.issues[0].message).exit("error");
+    return;
+  }
+  const auth = await getAuthData();
+  auth.addEventListener((state) => Object.assign(auth, state));
+  const fetchResult = await fetchFromRegistry(
+    registry(namespace).apis(slug).url({
+      version: result.data.version,
+      format: result.data.format
+    }),
+    auth.accessToken
+  );
+  if (fetchResult.error) {
+    output.error().title("Unable to download document").message(fetchResult.message).exit("error");
+    return;
+  }
+  const document = fetchResult.data;
+  const withTrailingNewline = document.endsWith("\n") ? document : `${document}
+`;
+  if (result.data.output) {
+    try {
+      await fs.writeFile(result.data.output, withTrailingNewline, "utf8");
+    } catch (error) {
+      const message = error instanceof Error && error.message.length > 0 ? error.message : `Could not write to ${result.data.output}.`;
+      output.error().title("Unable to write document to file").message(message).exit("error");
+      return;
+    }
+    output.info().line(
+      `Downloaded ${namespace}/${slug}@${result.data.version} (${result.data.format})`
+    ).line(`Written to ${result.data.output}`).print();
+    return;
+  }
+  process.stdout.write(withTrailingNewline);
+}
+export {
+  getAction
+};