fuma-content 0.0.2 → 1.0.0

package/dist/chunk-ERBMAQYP.js

@@ -0,0 +1,33 @@
+// src/plugins/with-loader/index.ts
+function withLoader(plugin, { test, createLoader }) {
+  let loader;
+  return {
+    bun: {
+      async build(build) {
+        const { toBun } = await import("./bun-DMNX4PBC.js");
+        toBun(test, await (loader ??= createLoader.call(this, "bun")))(build);
+      }
+    },
+    node: {
+      async createLoad() {
+        const { toNode } = await import("./node-DCMYL4DL.js");
+        return toNode(test, await (loader ??= createLoader.call(this, "node")));
+      }
+    },
+    vite: {
+      async createPlugin() {
+        const { toVite } = await import("./vite-QCUPZHHB.js");
+        return toVite(
+          plugin.name,
+          test,
+          await (loader ??= createLoader.call(this, "vite"))
+        );
+      }
+    },
+    ...plugin
+  };
+}
+
+export {
+  withLoader
+};

package/dist/chunk-IGLM4N4P.js

@@ -0,0 +1,34 @@
+// src/config/build.ts
+function buildConfig(config, workspace) {
+  const collections = /* @__PURE__ */ new Map();
+  const loaded = {};
+  const globalConfig = config.default ?? config;
+  if (globalConfig.collections) {
+    for (const [name, collection] of Object.entries(globalConfig.collections)) {
+      collection.init?.({ name, workspace });
+      collections.set(name, collection);
+    }
+  }
+  return {
+    ...globalConfig,
+    collections,
+    workspaces: Object.fromEntries(
+      Object.entries(loaded.workspaces ?? {}).map(([key, value]) => {
+        return [
+          key,
+          {
+            dir: value.dir,
+            config: buildConfig(value.config, {
+              ...value,
+              name: key
+            })
+          }
+        ];
+      })
+    )
+  };
+}
+
+export {
+  buildConfig
+};

package/dist/chunk-LDBQ66H3.js

@@ -0,0 +1,38 @@
+// src/config/dynamic.ts
+import fs from "fs/promises";
+function createDynamicCore({
+  core,
+  buildConfig,
+  mode
+}) {
+  let prev;
+  async function getConfigHash() {
+    if (mode === "production") return "static";
+    const stats = await fs.stat(core.getOptions().configPath).catch(() => {
+      throw new Error("Cannot find config file");
+    });
+    return stats.mtime.getTime().toString();
+  }
+  return {
+    async getCore() {
+      const hash = await getConfigHash();
+      if (!prev || hash !== prev.hash) {
+        prev = {
+          hash,
+          init: (async () => {
+            const { loadConfig } = await import("./load-from-file-MLL4WQ5J.js");
+            await core.init({
+              config: loadConfig(core, buildConfig)
+            });
+          })()
+        };
+      }
+      await prev.init;
+      return core;
+    }
+  };
+}
+
+export {
+  createDynamicCore
+};

package/dist/chunk-M72VQL5M.js

@@ -0,0 +1,40 @@
+import {
+  buildConfig
+} from "./chunk-IGLM4N4P.js";
+
+// src/config/load-from-file.ts
+import { pathToFileURL } from "url";
+async function compileConfig(core) {
+  const { build } = await import("esbuild");
+  const { configPath, outDir } = core.getOptions();
+  const transformed = await build({
+    entryPoints: [{ in: configPath, out: "content.config" }],
+    bundle: true,
+    outdir: outDir,
+    target: "node20",
+    write: true,
+    platform: "node",
+    format: "esm",
+    packages: "external",
+    outExtension: {
+      ".js": ".mjs"
+    },
+    allowOverwrite: true
+  });
+  if (transformed.errors.length > 0) {
+    throw new Error("failed to compile configuration file");
+  }
+}
+async function loadConfig(core, build = false) {
+  if (build) await compileConfig(core);
+  const url = pathToFileURL(core.getCompiledConfigPath());
+  url.searchParams.set("hash", Date.now().toString());
+  const config = import(url.href).then(
+    (loaded) => buildConfig(loaded)
+  );
+  return await config;
+}
+
+export {
+  loadConfig
+};

package/dist/chunk-OUJENWQ4.js

@@ -0,0 +1,45 @@
+// src/utils/validation.ts
+var ValidationError = class extends Error {
+  title;
+  issues;
+  constructor(message, issues) {
+    super(
+      `${message}:
+${issues.map((issue) => `  ${issue.path}: ${issue.message}`).join("\n")}`
+    );
+    this.title = message;
+    this.issues = issues;
+  }
+  async toStringFormatted() {
+    const picocolorsModule = await import("picocolors");
+    const picocolors = picocolorsModule.default ?? picocolorsModule;
+    return [
+      picocolors.bold(`[MDX] ${this.title}:`),
+      ...this.issues.map(
+        (issue) => picocolors.redBright(
+          `- ${picocolors.bold(issue.path?.join(".") ?? "*")}: ${issue.message}`
+        )
+      )
+    ].join("\n");
+  }
+};
+async function validate(schema, data, context, errorMessage) {
+  if (typeof schema === "function" && !("~standard" in schema)) {
+    schema = schema(context);
+  }
+  if ("~standard" in schema) {
+    const result = await schema["~standard"].validate(
+      data
+    );
+    if (result.issues) {
+      throw new ValidationError(errorMessage, result.issues);
+    }
+    return result.value;
+  }
+  return data;
+}
+
+export {
+  ValidationError,
+  validate
+};

package/dist/chunk-PNA5UGSL.js

@@ -0,0 +1,104 @@
+import {
+  fumaMatter
+} from "./chunk-VWJKRQZR.js";
+
+// src/collections/mdx/loader.ts
+import { z } from "zod";
+import fs from "fs/promises";
+import path from "path";
+import { createHash } from "crypto";
+var querySchema = z.object({
+  only: z.literal(["frontmatter", "all"]).default("all"),
+  collection: z.string().optional(),
+  workspace: z.string().optional()
+}).loose();
+var cacheEntry = z.object({
+  code: z.string(),
+  map: z.any().optional(),
+  hash: z.string().optional()
+});
+function createMdxLoader({ getCore }) {
+  return {
+    async load({
+      getSource,
+      development: isDevelopment,
+      query,
+      compiler,
+      filePath
+    }) {
+      let core = await getCore();
+      const value = await getSource();
+      const matter = fumaMatter(value);
+      const {
+        collection: collectionName,
+        workspace,
+        only
+      } = querySchema.parse(query);
+      if (workspace) {
+        core = core.getWorkspaces().get(workspace) ?? core;
+      }
+      let after;
+      const { experimentalBuildCache = false } = core.getConfig();
+      if (!isDevelopment && experimentalBuildCache) {
+        const cacheDir = experimentalBuildCache;
+        const cacheKey = `${collectionName ?? "global"}_${generateCacheHash(filePath)}`;
+        const cached = await fs.readFile(path.join(cacheDir, cacheKey)).then((content) => cacheEntry.parse(JSON.parse(content.toString()))).catch(() => null);
+        if (cached && cached.hash === generateCacheHash(value)) return cached;
+        after = async () => {
+          await fs.mkdir(cacheDir, { recursive: true });
+          await fs.writeFile(
+            path.join(cacheDir, cacheKey),
+            JSON.stringify({
+              ...out,
+              hash: generateCacheHash(value)
+            })
+          );
+        };
+      }
+      const collection = collectionName ? core.getCollection(collectionName) : void 0;
+      const handler = collection?.handlers.mdx;
+      if (collection && handler?.frontmatter) {
+        matter.data = await handler.frontmatter.call(
+          { collection, filePath, source: value },
+          matter.data
+        );
+      }
+      if (only === "frontmatter") {
+        return {
+          code: `export const frontmatter = ${JSON.stringify(matter.data)}`,
+          map: null
+        };
+      }
+      const lineOffset = isDevelopment ? countLines(matter.matter) : 0;
+      const { buildMDX } = await import("./build-mdx-Q4RMDWYK.js");
+      const compiled = await buildMDX(core, collection, {
+        isDevelopment,
+        source: "\n".repeat(lineOffset) + matter.content,
+        filePath,
+        frontmatter: matter.data,
+        _compiler: compiler,
+        environment: "bundler"
+      });
+      const out = {
+        code: String(compiled.value),
+        map: compiled.map
+      };
+      await after?.();
+      return out;
+    }
+  };
+}
+function generateCacheHash(input) {
+  return createHash("md5").update(input).digest("hex");
+}
+function countLines(s) {
+  let num = 0;
+  for (const c of s) {
+    if (c === "\n") num++;
+  }
+  return num;
+}
+
+export {
+  createMdxLoader
+};

package/dist/chunk-RMSV4HP6.js

@@ -0,0 +1,85 @@
+import {
+  validate
+} from "./chunk-OUJENWQ4.js";
+
+// src/collections/meta/loader.ts
+import { dump, load } from "js-yaml";
+import { z } from "zod";
+var querySchema = z.object({
+  collection: z.string().optional(),
+  workspace: z.string().optional()
+}).loose();
+function createMetaLoader({ getCore }, resolve = {}) {
+  const { json: resolveJson = "js", yaml: resolveYaml = "js" } = resolve;
+  function parse(filePath, source) {
+    try {
+      if (filePath.endsWith(".json")) return JSON.parse(source);
+      if (filePath.endsWith(".yaml")) return load(source);
+    } catch (e) {
+      throw new Error(`invalid data in ${filePath}`, { cause: e });
+    }
+    throw new Error(`Unknown file type ${filePath}`);
+  }
+  function onMeta(source, { filePath, query }) {
+    const parsed = querySchema.safeParse(query);
+    if (!parsed.success || !parsed.data.collection) return null;
+    const { collection: collectionName, workspace } = parsed.data;
+    return async () => {
+      let core = await getCore();
+      if (workspace) {
+        core = core.getWorkspaces().get(workspace) ?? core;
+      }
+      const collection = core.getCollection(collectionName);
+      const handler = collection?.handlers.meta;
+      let data = parse(filePath, source);
+      if (!handler) return data;
+      const context = {
+        path: filePath,
+        source
+      };
+      if (handler.schema) {
+        data = await validate(
+          handler.schema,
+          data,
+          context,
+          `invalid data in ${filePath}`
+        );
+      }
+      return handler.transform?.call(context, data);
+    };
+  }
+  return {
+    async load(input) {
+      const result = onMeta(await input.getSource(), input);
+      if (result === null) return null;
+      const data = await result();
+      if (input.filePath.endsWith(".json")) {
+        return {
+          code: resolveJson === "json" ? JSON.stringify(data) : `export default ${JSON.stringify(data)}`
+        };
+      } else {
+        return {
+          code: resolveYaml === "yaml" ? dump(data) : `export default ${JSON.stringify(data)}`
+        };
+      }
+    },
+    bun: {
+      load(source, input) {
+        const result = onMeta(source, input);
+        if (result === null)
+          return {
+            loader: "object",
+            exports: parse(input.filePath, source)
+          };
+        return result().then((data) => ({
+          loader: "object",
+          exports: { default: data }
+        }));
+      }
+    }
+  };
+}
+
+export {
+  createMetaLoader
+};

package/dist/chunk-RXR7OL76.js

@@ -0,0 +1,37 @@
+import {
+  SimpleCollectionStore
+} from "./chunk-3VQS3KSP.js";
+
+// src/collections/runtime/file-store.ts
+import path from "path";
+function fileInfo(base, globKey) {
+  if (globKey.startsWith("./")) {
+    globKey = globKey.slice(2);
+  }
+  return {
+    path: globKey,
+    fullPath: path.join(base, globKey)
+  };
+}
+var FileCollectionStore = class extends SimpleCollectionStore {
+  constructor(base, glob) {
+    const data = /* @__PURE__ */ new Map();
+    for (const [key, value] of Object.entries(glob)) {
+      data.set(key, {
+        ...value,
+        ...fileInfo(base, key)
+      });
+    }
+    super(data);
+  }
+  transform(fn) {
+    return super.transform(fn);
+  }
+  $data(_cast) {
+    return super.$data(_cast);
+  }
+};
+
+export {
+  FileCollectionStore
+};

package/dist/chunk-VWJKRQZR.js

@@ -0,0 +1,19 @@
+// src/utils/fuma-matter.ts
+import { load } from "js-yaml";
+var regex = /^---\r?\n(.+?)\r?\n---\r?\n/s;
+function fumaMatter(input) {
+  const output = { matter: "", data: {}, content: input };
+  const match = regex.exec(input);
+  if (!match) {
+    return output;
+  }
+  output.matter = match[0];
+  output.content = input.slice(match[0].length);
+  const loaded = load(match[1]);
+  output.data = loaded ?? {};
+  return output;
+}
+
+export {
+  fumaMatter
+};