@orbytes/astrolab 0.3.0

package/dist/core/astro-integration.js

@@ -0,0 +1,130 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import colors from "yoctocolors";
+import { APP_PAGE } from "./lib-paths.js";
+import { resolveOptions } from "./options.js";
+import { createPathBuilder } from "./utils/path-builder.js";
+import {
+  createVirtualRouteComponent,
+  getVirtualRoutes
+} from "./virtual-module/virtual-routes.js";
+import { createVirtualFilesPlugin } from "./virtual-module/vite-plugin.js";
+function createAstrobookIntegration(userOptions) {
+  let astrobookBaseForLogging;
+  const resolvedOptions = resolveOptions(userOptions);
+  return {
+    name: "astrobook",
+    hooks: {
+      "astro:config:setup": async ({
+        updateConfig,
+        injectRoute,
+        createCodegenDir,
+        config,
+        logger,
+        command
+      }) => {
+        const rootDir = path.resolve(
+          fileURLToPath(config.root),
+          resolvedOptions.directory
+        );
+        const astroBase = config.base || "";
+        const astrobookSubpath = resolvedOptions.subpath;
+        const buildPath = createPathBuilder({
+          trailingSlash: config.trailingSlash
+        });
+        const dashboardSubpath = buildPath(
+          astrobookSubpath,
+          resolvedOptions.dashboardSubpath
+        );
+        const previewSubpath = buildPath(
+          astrobookSubpath,
+          resolvedOptions.previewSubpath
+        );
+        if (dashboardSubpath === previewSubpath) {
+          throw new Error(
+            "[Astrobook] The dashboard and preview subpaths cannot be the same. Please set different values for `dashboardSubpath` and `previewSubpath` options."
+          );
+        }
+        const astrobookBase = buildPath(astroBase, astrobookSubpath);
+        const dashboardBase = buildPath(astroBase, dashboardSubpath);
+        const storyBase = buildPath(astroBase, previewSubpath);
+        if (astrobookSubpath && command === "dev") {
+          astrobookBaseForLogging = astrobookBase;
+        } else {
+          astrobookBaseForLogging = void 0;
+        }
+        logger.debug(`Creating dedicated folder`);
+        const codegenDir = fileURLToPath(createCodegenDir());
+        logger.debug(`Created dedicated folder at ${codegenDir}`);
+        logger.debug(`Scanning for stories in ${rootDir}`);
+        const routes = await getVirtualRoutes(
+          rootDir,
+          codegenDir,
+          logger,
+          dashboardSubpath,
+          previewSubpath,
+          buildPath
+        );
+        logger.debug(`Writing files to ${codegenDir}`);
+        await Promise.all(
+          Array.from(routes.values(), async (route) => {
+            const filePath = route.entrypoint;
+            const fileContent = createVirtualRouteComponent(route);
+            await fs.mkdir(path.dirname(filePath), { recursive: true });
+            await fs.writeFile(filePath, fileContent, { encoding: "utf-8" });
+          })
+        );
+        updateConfig({
+          vite: {
+            plugins: [
+              createVirtualFilesPlugin(
+                rootDir,
+                {
+                  astrobookBase,
+                  dashboardBase,
+                  storyBase,
+                  head: resolvedOptions.head,
+                  home: resolvedOptions.home,
+                  homeContent: resolvedOptions.homeContent,
+                  css: resolvedOptions.css,
+                  title: resolvedOptions.title,
+                  trailingSlash: config.trailingSlash
+                },
+                config,
+                logger
+              )
+            ]
+          }
+        });
+        logger.debug(`Injecting routes`);
+        for (const route of routes.values()) {
+          injectRoute({
+            pattern: route.pattern,
+            entrypoint: route.entrypoint,
+            prerender: true
+          });
+        }
+        injectRoute({
+          pattern: astrobookSubpath,
+          entrypoint: APP_PAGE,
+          prerender: true
+        });
+      },
+      "astro:server:start": ({ logger, address }) => {
+        if (astrobookBaseForLogging) {
+          const url = new URL(
+            astrobookBaseForLogging,
+            `http://localhost:${address.port}`
+          );
+          const message = colors.bgGreen(colors.white(colors.bold(" astrobook "))) + " is available at " + colors.cyan(url.href);
+          const plainLogger = logger.fork("SKIP_FORMAT");
+          plainLogger.info(message);
+        }
+      }
+    }
+  };
+}
+export {
+  createAstrobookIntegration
+};

package/dist/core/index.js

@@ -0,0 +1,6 @@
+import {
+  createAstrobookIntegration
+} from "./astro-integration.js";
+export {
+  createAstrobookIntegration
+};

package/dist/core/lib-paths.js

@@ -0,0 +1,29 @@
+import { fileURLToPath } from "node:url";
+import slash from "slash";
+const LIB_BASE = new URL(
+  import.meta.url.endsWith("/dist/core/lib-paths.js") ? "../../src/core/" : "./",
+  import.meta.url
+);
+function libFile(relative) {
+  return slash(fileURLToPath(new URL(relative, LIB_BASE)));
+}
+const CLIENT_MODULE = libFile("./client.ts");
+const STORY_PAGE = libFile("./lib/pages/story.astro");
+const PREVIEW_PAGE = libFile("./lib/pages/preview.astro");
+const APP_PAGE = libFile("./lib/pages/app.astro");
+const WITH_DECORATORS_COMPONENT = libFile(
+  "./lib/components/with-decorators.astro"
+);
+const HEAD_COMPONENT = libFile("./lib/components/head.astro");
+const HOME_COMPONENT = libFile("./lib/components/home.astro");
+const EMPTY_COMPONENT = libFile("./lib/components/empty.astro");
+export {
+  APP_PAGE,
+  CLIENT_MODULE,
+  EMPTY_COMPONENT,
+  HEAD_COMPONENT,
+  HOME_COMPONENT,
+  PREVIEW_PAGE,
+  STORY_PAGE,
+  WITH_DECORATORS_COMPONENT
+};

package/dist/core/options.js

@@ -0,0 +1,173 @@
+import {
+  EMPTY_COMPONENT,
+  HEAD_COMPONENT,
+  HOME_COMPONENT
+} from "./lib-paths.js";
+const ASTROBOOK_VERSION = "0.13.3";
+const DEFAULT_VERSION_HREF = "https://github.com/ocavue/astrobook/blob/master/packages/astrobook/CHANGELOG.md";
+const DEFAULT_REPO_HREF = "https://github.com/ocavue/astrobook";
+function stringify(value) {
+  switch (typeof value) {
+    case "string":
+      return `"${value}"`;
+    case "number":
+    case "bigint":
+    case "boolean":
+      return String(value);
+    case "symbol":
+    case "function":
+      return value.toString();
+    case "object":
+      return value === null ? "null" : Array.isArray(value) ? "Array" : "Object";
+    default:
+      return "undefined";
+  }
+}
+function typeIssue(expected, value, path) {
+  return {
+    message: `Invalid type: Expected ${expected} but received ${stringify(value)}`,
+    path
+  };
+}
+function readString(value, fallback, path, issues) {
+  if (value === void 0) return fallback;
+  if (typeof value !== "string") {
+    issues.push(typeIssue("string", value, path));
+    return fallback;
+  }
+  return value;
+}
+function readStringArray(value, path, issues) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value)) {
+    issues.push(typeIssue("Array", value, path));
+    return [];
+  }
+  const result = [];
+  value.forEach((item, index) => {
+    if (typeof item !== "string") {
+      issues.push(typeIssue("string", item, `${path}.${index}`));
+      return;
+    }
+    result.push(item);
+  });
+  return result;
+}
+function readStringOrFalse(value, fallback, path, issues) {
+  if (value === void 0) return fallback;
+  if (value === false) return false;
+  if (typeof value !== "string") {
+    issues.push(typeIssue("(string | false)", value, path));
+    return fallback;
+  }
+  return value;
+}
+function readBadge(value, defaults, path, issues) {
+  if (value === void 0) return { ...defaults };
+  if (value === false) return false;
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    issues.push(typeIssue("(Object | false)", value, path));
+    return { ...defaults };
+  }
+  const badge = value;
+  return {
+    href: readString(badge["href"], defaults.href, `${path}.href`, issues),
+    label: readString(badge["label"], defaults.label, `${path}.label`, issues)
+  };
+}
+function readHomeContent(value, issues) {
+  let content = {};
+  if (value !== void 0) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      issues.push(typeIssue("Object", value, "homeContent"));
+    } else {
+      content = value;
+    }
+  }
+  return {
+    title: readStringOrFalse(
+      content["title"],
+      "Astrobook",
+      "homeContent.title",
+      issues
+    ),
+    subtitle: readStringOrFalse(
+      content["subtitle"],
+      "The minimal UI component playground",
+      "homeContent.subtitle",
+      issues
+    ),
+    version: readBadge(
+      content["version"],
+      { href: DEFAULT_VERSION_HREF, label: `v${ASTROBOOK_VERSION}` },
+      "homeContent.version",
+      issues
+    ),
+    repo: readBadge(
+      content["repo"],
+      { href: DEFAULT_REPO_HREF, label: "Star on GitHub" },
+      "homeContent.repo",
+      issues
+    )
+  };
+}
+function readHome(value, issues) {
+  if (value === void 0) return HOME_COMPONENT;
+  if (value === false) return EMPTY_COMPONENT;
+  if (typeof value !== "string") {
+    issues.push(typeIssue("(string | false)", value, "home"));
+    return HOME_COMPONENT;
+  }
+  if (value.length === 0) {
+    issues.push({
+      message: "Invalid length: Expected >=1 but received 0",
+      path: "home"
+    });
+    return HOME_COMPONENT;
+  }
+  return value;
+}
+function resolveOptions(options) {
+  const issues = [];
+  let input = {};
+  if (options !== void 0) {
+    if (typeof options !== "object" || options === null) {
+      issues.push(typeIssue("Object", options, ""));
+    } else {
+      input = options;
+    }
+  }
+  const resolved = {
+    directory: readString(input["directory"], ".", "directory", issues),
+    subpath: readString(input["subpath"], "", "subpath", issues),
+    dashboardSubpath: readString(
+      input["dashboardSubpath"],
+      "dashboard",
+      "dashboardSubpath",
+      issues
+    ),
+    previewSubpath: readString(
+      input["previewSubpath"],
+      "stories",
+      "previewSubpath",
+      issues
+    ),
+    title: readString(input["title"], "Astrobook", "title", issues),
+    css: readStringArray(input["css"], "css", issues),
+    head: readString(input["head"], HEAD_COMPONENT, "head", issues),
+    home: readHome(input["home"], issues),
+    homeContent: readHomeContent(input["homeContent"], issues)
+  };
+  if (issues.length > 0) {
+    const summary = issues.map(
+      (issue) => issue.path ? `\xD7 ${issue.message}
+  \u2192 at ${issue.path}` : `\xD7 ${issue.message}`
+    ).join("\n");
+    throw new Error(`Invalid Astrobook options:
+${summary}`);
+  }
+  return resolved;
+}
+export {
+  resolveOptions
+};

package/dist/core/utils/get-exports.js

@@ -0,0 +1,52 @@
+import { tsPlugin } from "@sveltejs/acorn-typescript";
+import { Parser } from "acorn";
+function getExports(code) {
+  const parser = Parser.extend(
+    tsPlugin({
+      dts: false,
+      jsx: {
+        allowNamespaces: true,
+        allowNamespacedObjects: true
+      }
+    })
+  );
+  const ast = parser.parse(code, {
+    sourceType: "module",
+    ecmaVersion: "latest",
+    allowImportExportEverywhere: true,
+    locations: true
+  });
+  const exports = /* @__PURE__ */ new Set();
+  for (const node of ast.body) {
+    if (node.type === "ExportNamedDeclaration") {
+      for (const specifier of node.specifiers) {
+        const { exported } = specifier;
+        if (exported.type === "Identifier") {
+          exports.add(exported.name);
+        }
+      }
+      const { declaration } = node;
+      if (declaration?.type === "VariableDeclaration") {
+        const { declarations } = declaration;
+        for (const declaration2 of declarations) {
+          const id = declaration2.id;
+          if (id.type === "Identifier") {
+            exports.add(id.name);
+          }
+        }
+      }
+      if (declaration?.type === "FunctionDeclaration") {
+        exports.add(declaration.id.name);
+      }
+      if (declaration?.type === "ClassDeclaration") {
+        exports.add(declaration.id.name);
+      }
+    } else if (node.type === "ExportDefaultDeclaration") {
+      exports.add("default");
+    }
+  }
+  return Array.from(exports).sort();
+}
+export {
+  getExports
+};

package/dist/core/utils/invariant.js

@@ -0,0 +1,12 @@
+import assert from "node:assert";
+function invariant(condition, message = "Unexpected invariant violation") {
+  if (!condition) {
+    assert(
+      condition,
+      `[astrobook] Unexpected internal error. Please open an issue at https://github.com/ocavue/astrobook/issues. ${message}`
+    );
+  }
+}
+export {
+  invariant
+};

package/dist/core/utils/kebab-case.js

@@ -0,0 +1,15 @@
+const wordSeparators = /[\s\u2000-\u206F\u2E00-\u2E7F\\'!"#$%&()*+,\-.\/:;<=>?@\[\]^_`{|}~]+/;
+const capital_plus_lower = /[A-ZÀ-Ý\u00C0-\u00D6\u00D9-\u00DD][a-zà-ÿ]/g;
+const capitals = /[A-ZÀ-Ý\u00C0-\u00D6\u00D9-\u00DD]+/g;
+function kebabCase(str) {
+  str = str.replace(capital_plus_lower, function(match) {
+    return " " + (match[0].toLowerCase() || match[0]) + match[1];
+  });
+  str = str.replace(capitals, function(match) {
+    return " " + match.toLowerCase();
+  });
+  return str.trim().split(wordSeparators).join("-").replace(/^-/, "").replace(/-\s*$/, "");
+}
+export {
+  kebabCase as default
+};

package/dist/core/utils/path-builder.js

@@ -0,0 +1,22 @@
+import {
+  ensureLeadingSlash,
+  ensureTrailingSlash,
+  stripLeadingAndTrailingSlashes,
+  stripTrailingSlash
+} from "./path.js";
+function createPathBuilder({
+  trailingSlash = "ignore"
+}) {
+  return function buildPath(...parts) {
+    let result = parts.map(stripLeadingAndTrailingSlashes).filter(Boolean).join("/");
+    if (trailingSlash === "always") {
+      result = ensureTrailingSlash(result);
+    } else if (trailingSlash === "never") {
+      result = stripTrailingSlash(result);
+    }
+    return ensureLeadingSlash(result);
+  };
+}
+export {
+  createPathBuilder
+};

package/dist/core/utils/path.js

@@ -0,0 +1,53 @@
+function ensureLeadingSlash(href) {
+  if (href[0] !== "/") href = "/" + href;
+  return href;
+}
+function ensureTrailingSlash(href) {
+  if (href[href.length - 1] !== "/") href += "/";
+  return href;
+}
+function ensureLeadingAndTrailingSlashes(href) {
+  href = ensureLeadingSlash(href);
+  href = ensureTrailingSlash(href);
+  return href;
+}
+function stripLeadingSlash(href) {
+  while (href[0] === "/") href = href.slice(1);
+  return href;
+}
+function stripTrailingSlash(href) {
+  while (href[href.length - 1] === "/") href = href.slice(0, -1);
+  return href;
+}
+function stripLeadingAndTrailingSlashes(href) {
+  href = stripLeadingSlash(href);
+  href = stripTrailingSlash(href);
+  return href;
+}
+function stripHtmlExtension(path) {
+  const pathWithoutTrailingSlash = stripTrailingSlash(path);
+  return pathWithoutTrailingSlash.endsWith(".html") ? pathWithoutTrailingSlash.slice(0, -5) : path;
+}
+function ensureHtmlExtension(path) {
+  path = stripLeadingAndTrailingSlashes(path);
+  if (!path.endsWith(".html")) {
+    path = path ? path + ".html" : "/index.html";
+  }
+  return ensureLeadingSlash(path);
+}
+function stripExtension(path) {
+  const periodIndex = path.lastIndexOf(".");
+  return path.slice(0, periodIndex > -1 ? periodIndex : void 0);
+}
+export {
+  ensureHtmlExtension,
+  ensureLeadingAndTrailingSlashes,
+  ensureLeadingSlash,
+  ensureTrailingSlash,
+  stripExtension,
+  stripHtmlExtension,
+  stripLeadingAndTrailingSlashes,
+  stripLeadingSlash,
+  stripLeadingAndTrailingSlashes as stripSlashes,
+  stripTrailingSlash
+};

package/dist/core/virtual-module/get-story-modules.js

@@ -0,0 +1,60 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fdir } from "fdir";
+import slash from "slash";
+import { getExports } from "../utils/get-exports.js";
+import { invariant } from "../utils/invariant.js";
+import kebabCase from "../utils/kebab-case.js";
+async function listStoryFiles(rootDir) {
+  invariant(
+    path.isAbsolute(rootDir),
+    `Root directory must be absolute, but got '${rootDir}'`
+  );
+  const filePaths = await new fdir().withSymlinks().withFullPaths().normalize().glob("./**/*.stories.{ts,tsx,js,jsx,mts,mtsx,mjs,mjsx}").exclude((dirname) => dirname === "node_modules").crawl(rootDir).withPromise();
+  return filePaths.sort();
+}
+async function parseStoryFiles(filePath) {
+  const code = await fs.readFile(filePath, "utf-8");
+  const exports = getExports(code);
+  const defaultExport = exports.includes("default");
+  const namedExports = exports.filter((name) => name !== "default");
+  return { filePath, defaultExport, namedExports };
+}
+function convertStoryFileToModule(rootDir, file) {
+  if (file.namedExports.length === 0) {
+    console.warn(`[astrobook] File ${file.filePath} has no named exports`);
+    return;
+  }
+  if (!file.defaultExport) {
+    console.warn(`[astrobook] File ${file.filePath} has no default export`);
+    return;
+  }
+  const relativePath = path.normalize(path.relative(rootDir, file.filePath));
+  const relativePathWithoutStories = relativePath.replace(
+    /\.stories\.\w+$/i,
+    ""
+  );
+  const parts = relativePathWithoutStories.split(path.sep);
+  const directory = parts.slice(0, -1).join("/");
+  const name = parts.pop();
+  invariant(name, `Unexpected file path: ${file.filePath}`);
+  const moduleId = directory ? `${directory}/${kebabCase(name)}` : kebabCase(name);
+  return {
+    id: moduleId,
+    name,
+    directory,
+    importPath: slash(file.filePath),
+    stories: file.namedExports.map((name2) => {
+      return { id: `${moduleId}/${kebabCase(name2)}`, name: name2 };
+    })
+  };
+}
+async function getStoryModules(rootDir) {
+  const storyFilePaths = await listStoryFiles(rootDir);
+  const storyFiles = await Promise.all(storyFilePaths.map(parseStoryFiles));
+  return storyFiles.map((storyFile) => convertStoryFileToModule(rootDir, storyFile)).filter((module) => !!module);
+}
+export {
+  convertStoryFileToModule,
+  getStoryModules
+};

package/dist/core/virtual-module/story-modules.js

@@ -0,0 +1,8 @@
+import { getStoryModules } from "./get-story-modules.js";
+async function loadStoryModules(rootDir) {
+  const modules = await getStoryModules(rootDir);
+  return `export default ${JSON.stringify(modules)}`;
+}
+export {
+  loadStoryModules
+};

package/dist/core/virtual-module/virtual-module-ids.js

@@ -0,0 +1,22 @@
+const STORY_MODULES_ID = "virtual:astrobook/story-modules.mjs";
+const STORY_MODULES_RESOLVED_ID = "__virtual_astrobook_story_modules__.mjs";
+const GLOBAL_CONFIG_ID = "virtual:astrobook/global-config.mjs";
+const GLOBAL_CONFIG_RESOLVED_ID = "__virtual_astrobook_user_config__.mjs";
+const COMPONENT_HEAD_ID = "virtual:astrobook/components/head.mjs";
+const COMPONENT_HEAD_RESOLVED_ID = "__virtual_astrobook_COMPONENT_HEAD__.mjs";
+const COMPONENT_HOME_ID = "virtual:astrobook/components/home.mjs";
+const COMPONENT_HOME_RESOLVED_ID = "__virtual_astrobook_COMPONENT_HOME__.mjs";
+const USER_CSS_ID = "virtual:astrobook/user-css.mjs";
+const USER_CSS_RESOLVED_ID = "__virtual_astrobook_user_css__.mjs";
+export {
+  COMPONENT_HEAD_ID,
+  COMPONENT_HEAD_RESOLVED_ID,
+  COMPONENT_HOME_ID,
+  COMPONENT_HOME_RESOLVED_ID,
+  GLOBAL_CONFIG_ID,
+  GLOBAL_CONFIG_RESOLVED_ID,
+  STORY_MODULES_ID,
+  STORY_MODULES_RESOLVED_ID,
+  USER_CSS_ID,
+  USER_CSS_RESOLVED_ID
+};

package/dist/core/virtual-module/virtual-routes.js

@@ -0,0 +1,83 @@
+import path from "node:path";
+import slash from "slash";
+import {
+  CLIENT_MODULE,
+  PREVIEW_PAGE,
+  STORY_PAGE,
+  WITH_DECORATORS_COMPONENT
+} from "../lib-paths.js";
+import { invariant } from "../utils/invariant.js";
+import { getStoryModules } from "./get-story-modules.js";
+async function getVirtualRoutes(rootDir, codegenDir, logger, dashboardSubpath, previewSubpath, buildPath) {
+  const routes = [];
+  const storyModules = await getStoryModules(rootDir);
+  for (const storyModule of storyModules) {
+    logger.debug(
+      `Found ${storyModule.stories.length} stories in ${storyModule.importPath}`
+    );
+    for (const story of storyModule.stories) {
+      invariant(
+        !story.id.startsWith(".."),
+        `Story ID cannot start with '..', but got '${story.id}'`
+      );
+      invariant(
+        !story.id.startsWith("/"),
+        `Story ID cannot start with '/', but got '${story.id}'`
+      );
+      routes.push(
+        {
+          pattern: buildPath(dashboardSubpath, story.id),
+          entrypoint: slash(
+            path.resolve(codegenDir, "dashboard", story.id + ".astro")
+          ),
+          storyModule,
+          story,
+          props: { hasSidebar: true, story: story.id }
+        },
+        {
+          pattern: buildPath(previewSubpath, story.id),
+          entrypoint: slash(
+            path.resolve(codegenDir, "stories", story.id + ".astro")
+          ),
+          storyModule,
+          story,
+          props: { hasSidebar: false, story: story.id }
+        }
+      );
+    }
+  }
+  logger.info(`Found ${routes.length} stories in ${storyModules.length} files`);
+  return new Map(routes.map((route) => [route.pattern, route]));
+}
+function createVirtualRouteComponent(route) {
+  const modName = `astrobook_module_${route.storyModule.id}`.replaceAll(/\W+/g, "_").replaceAll(/_+/g, "_").replace(/_+$/, "");
+  const page = route.props.hasSidebar ? STORY_PAGE : PREVIEW_PAGE;
+  return `
+---
+// Automatically generated by Astrobook
+
+import StoryPage from '${page}';
+import WithDecorators from '${WITH_DECORATORS_COMPONENT}';
+import { parseStoryDefaultExport, parseStoryNamedExport } from '${CLIENT_MODULE}';
+
+import * as ${modName} from '${route.storyModule.importPath}';
+
+const { isAstroComponent } = parseStoryDefaultExport(${modName}, '${route.storyModule.importPath}');
+const { decorators, args } = parseStoryNamedExport(${modName}, '${route.storyModule.importPath}', '${route.story.name}');
+---
+
+<StoryPage story={'${route.props.story}'} hasSidebar={${route.props.hasSidebar}}>
+  <WithDecorators decorators={decorators}>
+    {isAstroComponent ? (
+      <${modName}.default.component {...args} />
+    ) : (
+      <${modName}.default.component {...args} client:load />
+    )}
+  </WithDecorators>
+</StoryPage>
+`.trim();
+}
+export {
+  createVirtualRouteComponent,
+  getVirtualRoutes
+};