fuma-content 1.0.1 → 1.0.3

package/dist/chunk-MT7RY65Y.js

@@ -1,167 +0,0 @@
-import {
-  createCache
-} from "./chunk-JBZTQ55D.js";
-
-// src/utils/code-generator.ts
-import path from "path";
-import { glob } from "tinyglobby";
-function importInfo() {
-  return {
-    named: /* @__PURE__ */ new Map(),
-    namespaces: /* @__PURE__ */ new Set(),
-    isUsed: /* @__PURE__ */ new Set()
-  };
-}
-var CodeGenerator = class {
-  lines = [];
-  globCache;
-  // specifier -> imported members/info
-  importInfos = /* @__PURE__ */ new Map();
-  eagerImportId = 0;
-  options;
-  constructor({
-    target = "default",
-    jsExtension = false,
-    globCache = /* @__PURE__ */ new Map(),
-    outDir = ""
-  }) {
-    this.options = {
-      target,
-      jsExtension,
-      globCache,
-      outDir
-    };
-    this.globCache = createCache(globCache);
-  }
-  addNamespaceImport(namespace, specifier, types = false) {
-    const info = this.importInfos.get(specifier) ?? importInfo();
-    this.importInfos.set(specifier, info);
-    if (!types) info.isUsed.add(namespace);
-    info.namespaces.add(namespace);
-  }
-  addNamedImport(names, specifier, types = false) {
-    const info = this.importInfos.get(specifier) ?? importInfo();
-    this.importInfos.set(specifier, info);
-    for (const name of names) {
-      const [memberName, importName = memberName] = name.split(/\s+as\s+/, 2);
-      info.named.set(importName, memberName);
-      if (!types) info.isUsed.add(importName);
-    }
-  }
-  push(...insert) {
-    this.lines.push(...insert);
-  }
-  async pushAsync(insert) {
-    for (const line of await Promise.all(insert)) {
-      if (line === void 0) continue;
-      this.lines.push(line);
-    }
-  }
-  async generateGlobImport(patterns, options) {
-    if (this.options.target === "vite") {
-      return this.generateViteGlobImport(patterns, options);
-    }
-    return this.generateNodeGlobImport(patterns, options);
-  }
-  generateViteGlobImport(patterns, { base, ...rest }) {
-    patterns = (typeof patterns === "string" ? [patterns] : patterns).map(
-      normalizeViteGlobPath
-    );
-    return `import.meta.glob(${JSON.stringify(patterns)}, ${JSON.stringify(
-      {
-        base: normalizeViteGlobPath(path.relative(this.options.outDir, base)),
-        ...rest
-      },
-      null,
-      2
-    )})`;
-  }
-  async generateNodeGlobImport(patterns, { base, eager = false, query = {}, import: importName }) {
-    const files = await this.globCache.cached(
-      JSON.stringify({ patterns, base }),
-      () => glob(patterns, {
-        cwd: base
-      })
-    );
-    let code = "{";
-    for (const item of files) {
-      const fullPath = path.join(base, item);
-      const searchParams = new URLSearchParams();
-      for (const [k, v] of Object.entries(query)) {
-        if (v !== void 0) searchParams.set(k, v);
-      }
-      const importPath = `${this.formatImportPath(fullPath)}?${searchParams.toString()}`;
-      if (eager) {
-        const name = `__fd_glob_${this.eagerImportId++}`;
-        this.lines.unshift(
-          importName ? `import { ${importName} as ${name} } from ${JSON.stringify(importPath)}` : `import * as ${name} from ${JSON.stringify(importPath)}`
-        );
-        code += `${JSON.stringify(item)}: ${name}, `;
-      } else {
-        let line = `${JSON.stringify(item)}: () => import(${JSON.stringify(importPath)})`;
-        if (importName) {
-          line += `.then(mod => mod.${importName})`;
-        }
-        code += `${line}, `;
-      }
-    }
-    code += "}";
-    return code;
-  }
-  formatImportPath(file) {
-    const ext = path.extname(file);
-    let filename;
-    if (ext === ".ts") {
-      filename = file.substring(0, file.length - ext.length);
-      if (this.options.jsExtension) filename += ".js";
-    } else {
-      filename = file;
-    }
-    const importPath = slash(path.relative(this.options.outDir, filename));
-    return importPath.startsWith(".") ? importPath : `./${importPath}`;
-  }
-  toString() {
-    const final = ["// @ts-nocheck"];
-    if (this.options.target === "vite") {
-      final.push('/// <reference types="vite/client" />');
-    }
-    for (const [specifier, info] of this.importInfos) {
-      const { namespaces, named, isUsed } = info;
-      for (const namespace of namespaces) {
-        final.push(
-          isUsed.has(namespace) ? `import * as ${namespace} from "${specifier}";` : `import type * as ${namespace} from "${specifier}";`
-        );
-      }
-      const namedImports = [];
-      for (const [importName, memberName] of named) {
-        const item = importName === memberName ? importName : `${memberName} as ${importName}`;
-        namedImports.push(isUsed.has(importName) ? item : `type ${item}`);
-      }
-      if (namedImports.length > 0) {
-        final.push(
-          `import { ${namedImports.join(", ")} } from "${specifier}";`
-        );
-      }
-    }
-    final.push(...this.lines);
-    return final.join("\n");
-  }
-};
-function normalizeViteGlobPath(file) {
-  file = slash(file);
-  if (file.startsWith("./")) return file;
-  if (file.startsWith("/")) return `.${file}`;
-  return `./${file}`;
-}
-function slash(path2) {
-  const isExtendedLengthPath = path2.startsWith("\\\\?\\");
-  if (isExtendedLengthPath) {
-    return path2;
-  }
-  return path2.replaceAll("\\", "/");
-}
-
-export {
-  CodeGenerator,
-  slash
-};

package/dist/chunk-NRZ4GE5O.js

@@ -1,207 +0,0 @@
-import {
-  CodeGenerator
-} from "./chunk-MT7RY65Y.js";
-
-// src/core.ts
-import path from "path";
-import fs from "fs/promises";
-async function getPlugins(pluginOptions) {
-  const plugins = [];
-  for (const option of await Promise.all(pluginOptions)) {
-    if (!option) continue;
-    if (Array.isArray(option)) plugins.push(...await getPlugins(option));
-    else plugins.push(option);
-  }
-  return plugins;
-}
-var Core = class _Core {
-  workspaces = /* @__PURE__ */ new Map();
-  options;
-  plugins = [];
-  config;
-  static defaultOptions = {
-    configPath: "content.config.ts",
-    outDir: ".content"
-  };
-  /**
-   * Convenient cache store, reset when config changes.
-   *
-   * You can group namespaces in cache key with ":", like `my-plugin:data`
-   */
-  cache = /* @__PURE__ */ new Map();
-  constructor(options) {
-    this.options = options;
-  }
-  async init({ config: newConfig }) {
-    this.config = await newConfig;
-    this.cache.clear();
-    this.workspaces.clear();
-    const loadedCollectionTypeIds = /* @__PURE__ */ new Set();
-    this.plugins = await getPlugins([
-      this.options.plugins,
-      this.config.plugins,
-      ...this.config.collections.values().map(({ typeInfo }) => {
-        if (loadedCollectionTypeIds.has(typeInfo.id)) return false;
-        loadedCollectionTypeIds.add(typeInfo.id);
-        return typeInfo.plugins;
-      })
-    ]);
-    const ctx = this.getPluginContext();
-    for (const plugin of this.plugins) {
-      const out = await plugin.config?.call(ctx, this.config);
-      if (out) this.config = out;
-    }
-    const { workspace, outDir } = this.options;
-    if (!workspace) {
-      await Promise.all(
-        Object.entries(this.config.workspaces).map(
-          async ([name, workspace2]) => {
-            const child = new _Core({
-              ...this.options,
-              outDir: path.join(outDir, name),
-              workspace: {
-                name,
-                parent: this,
-                dir: workspace2.dir
-              }
-            });
-            await child.init({ config: workspace2.config });
-            this.workspaces.set(name, child);
-          }
-        )
-      );
-    }
-    await Promise.all(
-      this.config.collections.values().map(async (collection) => {
-        for (const plugin of this.plugins) {
-          await plugin.collection?.call(ctx, collection);
-        }
-      })
-    );
-  }
-  getWorkspaces() {
-    return this.workspaces;
-  }
-  getOptions() {
-    return this.options;
-  }
-  getConfig() {
-    return this.config;
-  }
-  /**
-   * The file path of compiled config file, the file may not exist (e.g. on Vite, or still compiling)
-   */
-  getCompiledConfigPath() {
-    return path.join(this.options.outDir, "content.config.mjs");
-  }
-  getPlugins(workspace = false) {
-    if (workspace) {
-      const plugins = [...this.plugins];
-      for (const workspace2 of this.workspaces.values()) {
-        plugins.push(...workspace2.plugins);
-      }
-      return plugins;
-    }
-    return this.plugins;
-  }
-  getCollections(workspace = false) {
-    const list = Array.from(this.config.collections.values());
-    if (workspace) {
-      for (const workspace2 of this.workspaces.values()) {
-        list.push(...workspace2.getCollections());
-      }
-    }
-    return list;
-  }
-  getCollection(name) {
-    return this.config.collections.get(name);
-  }
-  getPluginContext() {
-    return {
-      core: this
-    };
-  }
-  async initServer(server) {
-    const ctx = this.getPluginContext();
-    const promises = [];
-    for (const plugin of this.plugins) {
-      promises.push(plugin.configureServer?.call(ctx, server));
-    }
-    for (const workspace of this.workspaces.values()) {
-      promises.push(workspace.initServer(server));
-    }
-    await Promise.all(promises);
-  }
-  async emit(emitOptions = {}) {
-    const {
-      workspace,
-      outDir,
-      emit: { target, jsExtension } = {}
-    } = this.options;
-    const { filterPlugin, filterWorkspace, write = false } = emitOptions;
-    const start = performance.now();
-    const globCache = /* @__PURE__ */ new Map();
-    const ctx = {
-      ...this.getPluginContext(),
-      createCodeGenerator: async (path2, content) => {
-        const codegen = new CodeGenerator({
-          target,
-          outDir,
-          jsExtension,
-          globCache
-        });
-        await content({
-          core: this,
-          codegen,
-          workspace: workspace?.name
-        });
-        return {
-          path: path2,
-          content: codegen.toString()
-        };
-      }
-    };
-    const added = /* @__PURE__ */ new Set();
-    const out = {
-      entries: [],
-      workspaces: {}
-    };
-    for (const li of await Promise.all(
-      this.plugins.map((plugin) => {
-        if (filterPlugin && !filterPlugin(plugin) || !plugin.emit)
-          return null;
-        return plugin.emit.call(ctx);
-      })
-    )) {
-      if (!li) continue;
-      for (const item of li) {
-        if (added.has(item.path)) continue;
-        out.entries.push(item);
-        added.add(item.path);
-      }
-    }
-    if (write) {
-      await Promise.all(
-        out.entries.map(async (entry) => {
-          const file = path.join(outDir, entry.path);
-          await fs.mkdir(path.dirname(file), { recursive: true });
-          await fs.writeFile(file, entry.content);
-        })
-      );
-      console.log(
-        workspace ? `[MDX: ${workspace.name}] generated files in ${performance.now() - start}ms` : `[MDX] generated files in ${performance.now() - start}ms`
-      );
-    }
-    await Promise.all(
-      this.workspaces.entries().map(async ([name, workspace2]) => {
-        if (filterWorkspace && !filterWorkspace(name)) return;
-        out.workspaces[name] = (await workspace2.emit(emitOptions)).entries;
-      })
-    );
-    return out;
-  }
-};
-
-export {
-  Core
-};