fuma-content 0.0.2 → 1.0.1

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
+};

package/dist/chunk-W6HENTK7.js

@@ -0,0 +1,44 @@
+// src/config/build.ts
+function buildConfig(config, workspace) {
+  const collections = /* @__PURE__ */ new Map();
+  const loaded = {};
+  let globalConfig;
+  if ("default" in config) {
+    globalConfig = config.default;
+    for (const [k, v] of Object.entries(config)) {
+      if (k === "default") continue;
+      globalConfig.collections ??= {};
+      globalConfig.collections[k] = v;
+    }
+  } else {
+    globalConfig = 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-XR5N6ZXJ.js

@@ -0,0 +1,50 @@
+import {
+  ValidationError
+} from "./chunk-OUJENWQ4.js";
+import {
+  Core
+} from "./chunk-NRZ4GE5O.js";
+
+// src/plugins/with-loader/webpack.ts
+import { parse } from "querystring";
+import path from "path";
+var core;
+function getCore(options) {
+  return core ??= new Core({
+    outDir: options.outDir,
+    configPath: options.configPath
+  });
+}
+function toWebpack(loader) {
+  return async function(source, callback) {
+    try {
+      const result = await loader.load({
+        filePath: this.resourcePath,
+        query: parse(this.resourceQuery.slice(1)),
+        getSource() {
+          return source;
+        },
+        development: this.mode === "development",
+        compiler: this
+      });
+      if (result === null) {
+        callback(void 0, source);
+      } else {
+        callback(void 0, result.code, result.map);
+      }
+    } catch (error) {
+      if (error instanceof ValidationError) {
+        return callback(new Error(await error.toStringFormatted()));
+      }
+      if (!(error instanceof Error)) throw error;
+      const fpath = path.relative(this.context, this.resourcePath);
+      error.message = `${fpath}:${error.name}: ${error.message}`;
+      callback(error);
+    }
+  };
+}
+
+export {
+  getCore,
+  toWebpack
+};

package/dist/collections/handlers/fs.d.ts

@@ -0,0 +1,10 @@
+export { m as FIleCollectionHandler, F as FileHandlerConfig, n as buildFileHandler } from '../../core-Bo8KaWQz.js';
+import 'chokidar';
+import '@mdx-js/mdx';
+import 'vfile';
+import '@standard-schema/spec';
+import 'unified';
+import 'mdast';
+import 'vite';
+import 'next';
+import 'node:module';

package/dist/collections/handlers/fs.js

@@ -0,0 +1,6 @@
+import {
+  buildFileHandler
+} from "../../chunk-E4HRKSP4.js";
+export {
+  buildFileHandler
+};

package/dist/collections/index.d.ts

@@ -0,0 +1,10 @@
+export { d as Collection, A as CollectionHandlers, z as CollectionTypeInfo, I as InitOptions, B as createCollection } from '../core-Bo8KaWQz.js';
+import 'chokidar';
+import '@mdx-js/mdx';
+import 'vfile';
+import '@standard-schema/spec';
+import 'unified';
+import 'mdast';
+import 'vite';
+import 'next';
+import 'node:module';

package/dist/collections/index.js

@@ -0,0 +1,6 @@
+import {
+  createCollection
+} from "../chunk-BTRE6MOX.js";
+export {
+  createCollection
+};

package/dist/collections/mdx/loader-webpack.d.ts

@@ -0,0 +1,17 @@
+import { LoaderContext } from 'webpack';
+import { WebpackLoaderOptions } from '../../plugins/with-loader/webpack.js';
+import '../../plugins/with-loader/index.js';
+import '../../core-Bo8KaWQz.js';
+import 'chokidar';
+import '@mdx-js/mdx';
+import 'vfile';
+import '@standard-schema/spec';
+import 'unified';
+import 'mdast';
+import 'vite';
+import 'next';
+import 'node:module';
+
+declare function loader(this: LoaderContext<WebpackLoaderOptions>, source: string): Promise<void>;
+
+export { loader as default };

package/dist/collections/mdx/loader-webpack.js

@@ -0,0 +1,39 @@
+import {
+  createMdxLoader
+} from "../../chunk-KH5GT2Y5.js";
+import {
+  getCore,
+  toWebpack
+} from "../../chunk-XR5N6ZXJ.js";
+import "../../chunk-OUJENWQ4.js";
+import {
+  createDynamicCore
+} from "../../chunk-GGL4EF6H.js";
+import "../../chunk-VWJKRQZR.js";
+import "../../chunk-NRZ4GE5O.js";
+import "../../chunk-MT7RY65Y.js";
+import "../../chunk-JBZTQ55D.js";
+
+// src/collections/mdx/loader-webpack.ts
+var instance;
+async function loader(source) {
+  const callback = this.async();
+  const options = this.getOptions();
+  this.cacheable(true);
+  this.addDependency(options.absoluteCompiledConfigPath);
+  if (!instance) {
+    instance = toWebpack(
+      createMdxLoader(
+        createDynamicCore({
+          core: getCore(options),
+          buildConfig: false,
+          mode: options.isDev ? "dev" : "production"
+        })
+      )
+    );
+  }
+  await instance.call(this, source, callback);
+}
+export {
+  loader as default
+};

package/dist/collections/mdx/runtime-browser.d.ts

@@ -0,0 +1,55 @@
+import { ReactNode } from 'react';
+import { CompiledMDXProperties } from './runtime.js';
+import { GetCollectionConfig } from '../../index.js';
+import { M as MDXCollection, E as ExtractedReference, V as VersionControlFileData } from '../../core-Bo8KaWQz.js';
+import { SimpleCollectionStore } from '../runtime/store.js';
+import '../runtime/file-store.js';
+import 'mdx/types';
+import 'chokidar';
+import '@mdx-js/mdx';
+import 'vfile';
+import '@standard-schema/spec';
+import 'unified';
+import 'mdast';
+import 'vite';
+import 'next';
+import 'node:module';
+
+interface AsyncCache<V> {
+    cached: (key: string, fn: () => V | Promise<V>) => V | Promise<V>;
+    $value: <T>() => AsyncCache<T>;
+    invalidate: (key: string) => void;
+}
+
+interface MDXStoreBrowserData<Frontmatter, CustomData> {
+    id: string;
+    preload: () => (CompiledMDXProperties<Frontmatter> & CustomData) | Promise<CompiledMDXProperties<Frontmatter> & CustomData>;
+    _renderer: StoreRendererData;
+}
+interface StoreRendererData {
+    storeId: string;
+    renderers: Map<string, {
+        fn: () => ReactNode;
+        forceOnDemand: boolean;
+    }>;
+}
+interface StoreData {
+    preloaded: AsyncCache<CompiledMDXProperties>;
+}
+type GetFrontmatter<Config, Name extends string> = GetCollectionConfig<Config, Name> extends MDXCollection<infer _Frontmatter> ? _Frontmatter : never;
+declare const _internal_data: Map<string, StoreData>;
+declare function mdxStoreBrowser<Config, Name extends string>(name: Name, _input: Record<string, () => Promise<unknown>>): SimpleCollectionStore<MDXStoreBrowserData<GetFrontmatter<Config, Name>, unknown>>;
+/**
+ * Renders content with `React.lazy`.
+ */
+declare function useRenderer<Frontmatter, CustomData>(entry: MDXStoreBrowserData<Frontmatter, CustomData> | undefined, renderFn: (data: CompiledMDXProperties<Frontmatter> & CustomData) => ReactNode): ReactNode;
+declare function $attachCompiled<Add>(): <T>(data: T) => T extends MDXStoreBrowserData<infer Frontmatter, infer CustomData> ? MDXStoreBrowserData<Frontmatter, CustomData & Add> : T;
+declare function $extractedReferences(): <T>(data: T) => T extends MDXStoreBrowserData<infer Frontmatter, infer CustomData> ? MDXStoreBrowserData<Frontmatter, CustomData & {
+    /**
+     * extracted references (e.g. hrefs, paths), useful for analyzing relationships between pages.
+     */
+    extractedReferences: ExtractedReference[];
+}> : T;
+declare function $versionControl(): <T>(data: T) => T extends MDXStoreBrowserData<infer Frontmatter, infer CustomData> ? MDXStoreBrowserData<Frontmatter, CustomData & VersionControlFileData> : T;
+
+export { $attachCompiled, $extractedReferences, $versionControl, type MDXStoreBrowserData, _internal_data, mdxStoreBrowser, useRenderer };

package/dist/collections/mdx/runtime-browser.js

@@ -0,0 +1,82 @@
+"use client";
+import {
+  SimpleCollectionStore
+} from "../../chunk-3VQS3KSP.js";
+import {
+  createCache
+} from "../../chunk-JBZTQ55D.js";
+
+// src/collections/mdx/runtime-browser.ts
+import { lazy, createElement } from "react";
+var _internal_data = /* @__PURE__ */ new Map();
+function mdxStoreBrowser(name, _input) {
+  const input = _input;
+  const merged = /* @__PURE__ */ new Map();
+  function getStoreData() {
+    let store = _internal_data.get(name);
+    if (store) return store;
+    store = {
+      preloaded: createCache()
+    };
+    _internal_data.set(name, store);
+    return store;
+  }
+  const _renderer = {
+    storeId: name,
+    renderers: /* @__PURE__ */ new Map()
+  };
+  for (const [key, value] of Object.entries(input)) {
+    merged.set(key, {
+      id: key,
+      preload() {
+        return getStoreData().preloaded.$value().cached(key, value);
+      },
+      _renderer
+    });
+  }
+  return new SimpleCollectionStore(merged);
+}
+function useRenderer(entry, renderFn) {
+  if (!entry) return null;
+  const {
+    id,
+    _renderer: { renderers }
+  } = entry;
+  let renderer = renderers.get(id);
+  if (!renderer) {
+    const OnDemand = lazy(async () => {
+      const loaded = await entry.preload();
+      return { default: () => renderFn(loaded) };
+    });
+    renderer = {
+      forceOnDemand: false,
+      fn() {
+        const v = entry.preload();
+        if (!(v instanceof Promise) && !this.forceOnDemand) {
+          return renderFn(v);
+        }
+        this.forceOnDemand = true;
+        return createElement(OnDemand);
+      }
+    };
+    renderers.set(id, renderer);
+  }
+  return renderer.fn();
+}
+function $attachCompiled() {
+  return (data) => data;
+}
+function $extractedReferences() {
+  return $attachCompiled();
+}
+function $versionControl() {
+  return $attachCompiled();
+}
+export {
+  $attachCompiled,
+  $extractedReferences,
+  $versionControl,
+  _internal_data,
+  mdxStoreBrowser,
+  useRenderer
+};

package/dist/collections/mdx/runtime-dynamic.d.ts

@@ -0,0 +1,43 @@
+import { C as CoreOptions, M as MDXCollection, E as ExtractedReference, V as VersionControlFileData } from '../../core-Bo8KaWQz.js';
+import { MDXComponents } from 'mdx/types';
+import { FC } from 'react';
+import { FileCollectionStore } from '../runtime/file-store.js';
+import { CompiledMDXProperties } from './runtime.js';
+import { GetCollectionConfig } from '../../index.js';
+import 'chokidar';
+import '@mdx-js/mdx';
+import 'vfile';
+import '@standard-schema/spec';
+import 'unified';
+import 'mdast';
+import 'vite';
+import 'next';
+import 'node:module';
+import '../runtime/store.js';
+
+interface MDXStoreDynamicData<Frontmatter> {
+    id: string;
+    frontmatter: Frontmatter;
+    compile: () => Promise<CompiledMDXProperties<Frontmatter>>;
+}
+type GetFrontmatter<Config, Name extends string> = GetCollectionConfig<Config, Name> extends MDXCollection<infer _Frontmatter> ? _Frontmatter : never;
+declare function mdxStoreDynamic<Config, Name extends string>(config: Config, coreOptions: CoreOptions, name: Name, base: string, _frontmatter: Record<string, unknown>): Promise<FileCollectionStore<MDXStoreDynamicData<GetFrontmatter<Config, Name>>>>;
+type MdxContent = FC<{
+    components?: MDXComponents;
+}>;
+declare function $attachCompiled<Add>(): <T>(data: T) => T extends MDXStoreDynamicData<unknown> ? T & {
+    compile: () => Promise<Awaited<ReturnType<T["compile"]>> & Add>;
+} : T;
+declare function $extractedReferences(): <T>(data: T) => T extends MDXStoreDynamicData<unknown> ? T & {
+    compile: () => Promise<Awaited<ReturnType<T["compile"]>> & {
+        /**
+         * extracted references (e.g. hrefs, paths), useful for analyzing relationships between pages.
+         */
+        extractedReferences: ExtractedReference[];
+    }>;
+} : T;
+declare function $versionControl(): <T>(data: T) => T extends MDXStoreDynamicData<unknown> ? T & {
+    compile: () => Promise<Awaited<ReturnType<T["compile"]>> & VersionControlFileData>;
+} : T;
+
+export { $attachCompiled, $extractedReferences, $versionControl, type MDXStoreDynamicData, type MdxContent, mdxStoreDynamic };

package/dist/collections/mdx/runtime-dynamic.js

@@ -0,0 +1,96 @@
+import {
+  buildMDX
+} from "../../chunk-OQQNA7L7.js";
+import {
+  FileCollectionStore
+} from "../../chunk-RXR7OL76.js";
+import {
+  fumaMatter
+} from "../../chunk-VWJKRQZR.js";
+import "../../chunk-3VQS3KSP.js";
+import {
+  buildConfig
+} from "../../chunk-W6HENTK7.js";
+import {
+  Core
+} from "../../chunk-NRZ4GE5O.js";
+import "../../chunk-MT7RY65Y.js";
+import {
+  createCache
+} from "../../chunk-JBZTQ55D.js";
+
+// src/collections/mdx/runtime-dynamic.ts
+import { pathToFileURL } from "url";
+import fs from "fs/promises";
+import jsxRuntimeDefault from "react/jsx-runtime";
+import path from "path";
+var corePromise;
+async function mdxStoreDynamic(config, coreOptions, name, base, _frontmatter) {
+  corePromise ??= (async () => {
+    const core2 = new Core(coreOptions);
+    await core2.init({
+      config: buildConfig(config)
+    });
+    return core2;
+  })();
+  const core = await corePromise;
+  const frontmatter = _frontmatter;
+  const collection = core.getCollection(name);
+  if (!collection || !collection.handlers.mdx)
+    throw new Error("invalid collection name");
+  const merged = {};
+  const cache = createCache();
+  for (const [k, v] of Object.entries(frontmatter)) {
+    merged[k] = {
+      id: k,
+      frontmatter: v,
+      async compile() {
+        return cache.cached(k, async () => {
+          const filePath = path.join(base, k);
+          let content = (await fs.readFile(filePath)).toString();
+          content = fumaMatter(content).content;
+          const compiled = await buildMDX(core, collection, {
+            filePath,
+            source: content,
+            frontmatter: v,
+            isDevelopment: false,
+            environment: "runtime"
+          });
+          return await executeMdx(String(compiled.value), {
+            baseUrl: pathToFileURL(filePath)
+          });
+        });
+      }
+    };
+  }
+  return new FileCollectionStore(base, merged);
+}
+var AsyncFunction = Object.getPrototypeOf(executeMdx).constructor;
+async function executeMdx(compiled, options = {}) {
+  const { opts: scopeOpts, ...scope } = options.scope ?? {};
+  const fullScope = {
+    opts: {
+      ...scopeOpts,
+      ...options.jsxRuntime ?? jsxRuntimeDefault,
+      baseUrl: options.baseUrl
+    },
+    ...scope
+  };
+  const hydrateFn = new AsyncFunction(...Object.keys(fullScope), compiled);
+  return await hydrateFn.apply(hydrateFn, Object.values(fullScope));
+}
+function $attachCompiled() {
+  return (data) => data;
+}
+function $extractedReferences() {
+  return $attachCompiled();
+}
+function $versionControl() {
+  return $attachCompiled();
+}
+export {
+  $attachCompiled,
+  $extractedReferences,
+  $versionControl,
+  mdxStoreDynamic
+};

package/dist/collections/mdx/runtime.d.ts

@@ -0,0 +1,70 @@
+import { GetCollectionConfig } from '../../index.js';
+import { M as MDXCollection, E as ExtractedReference, V as VersionControlFileData } from '../../core-Bo8KaWQz.js';
+import { FileCollectionStore } from '../runtime/file-store.js';
+import { FC } from 'react';
+import { MDXProps } from 'mdx/types';
+import 'chokidar';
+import '@mdx-js/mdx';
+import 'vfile';
+import '@standard-schema/spec';
+import 'unified';
+import 'mdast';
+import 'vite';
+import 'next';
+import 'node:module';
+import '../runtime/store.js';
+
+type CompiledMDXProperties<Frontmatter = Record<string, unknown>> = {
+    frontmatter: Frontmatter;
+    default: FC<MDXProps>;
+    /**
+     * Enable from `postprocess` option.
+     */
+    _markdown?: string;
+    /**
+     * Enable from `postprocess` option.
+     */
+    _mdast?: string;
+} & Record<string, unknown>;
+interface MDXStoreData<Frontmatter> {
+    id: string;
+    compiled: CompiledMDXProperties<Frontmatter>;
+}
+type GetFrontmatter<Config, Name extends string> = GetCollectionConfig<Config, Name> extends MDXCollection<infer _Frontmatter> ? _Frontmatter : never;
+declare function mdxStore<Config, Name extends string>(_name: Name, base: string, _input: Record<string, unknown>): FileCollectionStore<MDXStoreData<GetFrontmatter<Config, Name>>>;
+interface MDXStoreLazyData<Frontmatter> {
+    id: string;
+    frontmatter: Frontmatter;
+    load: () => Promise<CompiledMDXProperties<Frontmatter>>;
+}
+declare function mdxStoreLazy<Config, Name extends string>(_name: Name, base: string, _input: {
+    head: Record<string, unknown>;
+    body: Record<string, () => Promise<unknown>>;
+}): FileCollectionStore<MDXStoreLazyData<GetFrontmatter<Config, Name>>>;
+declare function $attachCompiled<Add>(): <T>(data: T) => T extends MDXStoreData<unknown> ? T & {
+    compiled: Add;
+} : T extends MDXStoreLazyData<unknown> ? T & {
+    load: () => Promise<Awaited<ReturnType<T["load"]>> & Add>;
+} : T;
+declare function $extractedReferences(): <T>(data: T) => T extends MDXStoreData<unknown> ? T & {
+    compiled: {
+        /**
+         * extracted references (e.g. hrefs, paths), useful for analyzing relationships between pages.
+         */
+        extractedReferences: ExtractedReference[];
+    };
+} : T extends MDXStoreLazyData<unknown> ? T & {
+    load: () => Promise<Awaited<ReturnType<T["load"]>> & {
+        /**
+         * extracted references (e.g. hrefs, paths), useful for analyzing relationships between pages.
+         */
+        extractedReferences: ExtractedReference[];
+    }>;
+} : T;
+declare function $versionControl(): <T>(data: T) => T extends MDXStoreData<unknown> ? T & {
+    compiled: VersionControlFileData;
+} : T extends MDXStoreLazyData<unknown> ? T & {
+    load: () => Promise<Awaited<ReturnType<T["load"]>> & VersionControlFileData>;
+} : T;
+
+export { $attachCompiled, $extractedReferences, $versionControl, type CompiledMDXProperties, type MDXStoreData, type MDXStoreLazyData, mdxStore, mdxStoreLazy };