@mandujs/core 0.41.2 → 0.43.0

package/src/content/digest.ts

@@ -1,133 +1,133 @@
-/**
- * Content Digest - 변경 감지용 해시 생성
- *
- * 콘텐츠의 고유 다이제스트를 생성하여 변경 감지에 사용
- * xxHash 스타일의 빠른 해시 또는 crypto 기반 SHA-256 사용
- */
-
-import { createHash } from "crypto";
-
-/**
- * 다이제스트 옵션
- */
-export interface DigestOptions {
-  /** 해시 알고리즘 (기본: sha256) */
-  algorithm?: "sha256" | "md5" | "sha1";
-  /** 출력 길이 (기본: 16) */
-  length?: number;
-}
-
-const DEFAULT_OPTIONS: DigestOptions = {
-  algorithm: "sha256",
-  length: 16,
-};
-
-/**
- * 데이터에서 다이제스트 생성
- *
- * @example
- * ```ts
- * const digest = generateDigest({ title: "Hello", content: "World" });
- * // → "a1b2c3d4e5f6g7h8"
- * ```
- */
-export function generateDigest(data: unknown, options?: DigestOptions): string {
-  const { algorithm, length } = { ...DEFAULT_OPTIONS, ...options };
-
-  const serialized = stableStringify(data);
-  const hash = createHash(algorithm!);
-  hash.update(serialized);
-
-  return hash.digest("hex").slice(0, length);
-}
-
-/**
- * 파일 내용에서 다이제스트 생성
- */
-export function generateFileDigest(content: string | Buffer, options?: DigestOptions): string {
-  const { algorithm, length } = { ...DEFAULT_OPTIONS, ...options };
-
-  const hash = createHash(algorithm!);
-  hash.update(content);
-
-  return hash.digest("hex").slice(0, length);
-}
-
-/**
- * 여러 소스를 결합한 다이제스트 생성
- *
- * @example
- * ```ts
- * const digest = combineDigests([
- *   generateDigest(frontmatter),
- *   generateFileDigest(body),
- * ]);
- * ```
- */
-export function combineDigests(digests: string[], options?: DigestOptions): string {
-  const { algorithm, length } = { ...DEFAULT_OPTIONS, ...options };
-
-  const combined = digests.join(":");
-  const hash = createHash(algorithm!);
-  hash.update(combined);
-
-  return hash.digest("hex").slice(0, length);
-}
-
-/**
- * 안정적인 JSON 문자열화 (키 순서 일관성 보장)
- */
-function stableStringify(obj: unknown): string {
-  if (obj === null || obj === undefined) {
-    return String(obj);
-  }
-
-  if (typeof obj !== "object") {
-    return JSON.stringify(obj);
-  }
-
-  if (Array.isArray(obj)) {
-    return "[" + obj.map(stableStringify).join(",") + "]";
-  }
-
-  if (obj instanceof Date) {
-    return JSON.stringify(obj.toISOString());
-  }
-
-  if (obj instanceof Map) {
-    const entries = Array.from(obj.entries()).sort(([a], [b]) =>
-      String(a).localeCompare(String(b))
-    );
-    return stableStringify(Object.fromEntries(entries));
-  }
-
-  if (obj instanceof Set) {
-    return stableStringify(Array.from(obj).sort());
-  }
-
-  // 일반 객체: 키를 정렬하여 직렬화
-  const keys = Object.keys(obj as Record<string, unknown>).sort();
-  const pairs = keys.map(
-    (key) => `${JSON.stringify(key)}:${stableStringify((obj as Record<string, unknown>)[key])}`
-  );
-
-  return "{" + pairs.join(",") + "}";
-}
-
-/**
- * 두 다이제스트 비교
- */
-export function digestsMatch(a: string | undefined, b: string | undefined): boolean {
-  if (!a || !b) return false;
-  return a === b;
-}
-
-/**
- * 다이제스트 기반 변경 감지
- */
-export function hasChanged(
-  newDigest: string,
-  oldDigest: string | undefined
-): boolean {
-  return !digestsMatch(newDigest, oldDigest);
-}
+/**
+ * Content Digest - 변경 감지용 해시 생성
+ *
+ * 콘텐츠의 고유 다이제스트를 생성하여 변경 감지에 사용
+ * xxHash 스타일의 빠른 해시 또는 crypto 기반 SHA-256 사용
+ */
+
+import { createHash } from "crypto";
+
+/**
+ * 다이제스트 옵션
+ */
+export interface DigestOptions {
+  /** 해시 알고리즘 (기본: sha256) */
+  algorithm?: "sha256" | "md5" | "sha1";
+  /** 출력 길이 (기본: 16) */
+  length?: number;
+}
+
+const DEFAULT_OPTIONS: DigestOptions = {
+  algorithm: "sha256",
+  length: 16,
+};
+
+/**
+ * 데이터에서 다이제스트 생성
+ *
+ * @example
+ * ```ts
+ * const digest = generateDigest({ title: "Hello", content: "World" });
+ * // → "a1b2c3d4e5f6g7h8"
+ * ```
+ */
+export function generateDigest(data: unknown, options?: DigestOptions): string {
+  const { algorithm, length } = { ...DEFAULT_OPTIONS, ...options };
+
+  const serialized = stableStringify(data);
+  const hash = createHash(algorithm!);
+  hash.update(serialized);
+
+  return hash.digest("hex").slice(0, length);
+}
+
+/**
+ * 파일 내용에서 다이제스트 생성
+ */
+export function generateFileDigest(content: string | Buffer, options?: DigestOptions): string {
+  const { algorithm, length } = { ...DEFAULT_OPTIONS, ...options };
+
+  const hash = createHash(algorithm!);
+  hash.update(content);
+
+  return hash.digest("hex").slice(0, length);
+}
+
+/**
+ * 여러 소스를 결합한 다이제스트 생성
+ *
+ * @example
+ * ```ts
+ * const digest = combineDigests([
+ *   generateDigest(frontmatter),
+ *   generateFileDigest(body),
+ * ]);
+ * ```
+ */
+export function combineDigests(digests: string[], options?: DigestOptions): string {
+  const { algorithm, length } = { ...DEFAULT_OPTIONS, ...options };
+
+  const combined = digests.join(":");
+  const hash = createHash(algorithm!);
+  hash.update(combined);
+
+  return hash.digest("hex").slice(0, length);
+}
+
+/**
+ * 안정적인 JSON 문자열화 (키 순서 일관성 보장)
+ */
+function stableStringify(obj: unknown): string {
+  if (obj === null || obj === undefined) {
+    return String(obj);
+  }
+
+  if (typeof obj !== "object") {
+    return JSON.stringify(obj);
+  }
+
+  if (Array.isArray(obj)) {
+    return "[" + obj.map(stableStringify).join(",") + "]";
+  }
+
+  if (obj instanceof Date) {
+    return JSON.stringify(obj.toISOString());
+  }
+
+  if (obj instanceof Map) {
+    const entries = Array.from(obj.entries()).sort(([a], [b]) =>
+      String(a).localeCompare(String(b))
+    );
+    return stableStringify(Object.fromEntries(entries));
+  }
+
+  if (obj instanceof Set) {
+    return stableStringify(Array.from(obj).sort());
+  }
+
+  // 일반 객체: 키를 정렬하여 직렬화
+  const keys = Object.keys(obj as Record<string, unknown>).sort();
+  const pairs = keys.map(
+    (key) => `${JSON.stringify(key)}:${stableStringify((obj as Record<string, unknown>)[key])}`
+  );
+
+  return "{" + pairs.join(",") + "}";
+}
+
+/**
+ * 두 다이제스트 비교
+ */
+export function digestsMatch(a: string | undefined, b: string | undefined): boolean {
+  if (!a || !b) return false;
+  return a === b;
+}
+
+/**
+ * 다이제스트 기반 변경 감지
+ */
+export function hasChanged(
+  newDigest: string,
+  oldDigest: string | undefined
+): boolean {
+  return !digestsMatch(newDigest, oldDigest);
+}

package/src/content/generate-types.ts

@@ -1,168 +1,168 @@
-/**
- * Content Types Generator (Issue #199)
- *
- * Emits `.mandu/generated/content-types.d.ts` with typed aliases for
- * every collection declared in `content.config.ts`. This gives users
- * full autocomplete on `docs.all()`, `docs.get(slug)`, etc. without
- * having to thread generics through every call site:
- *
- * ```ts
- * // user writes
- * import type { CollectionMap } from '.mandu/generated/content-types';
- * const entry = (await collections.docs.all())[0];
- * entry.data.title; // typed as string when schema has title: z.string()
- * ```
- *
- * # Contract
- *
- *   - Input: a map of collection-name → Collection instance (already
- *     returned from `defineCollection({ path, schema })`). We DO NOT
- *     re-execute `content.config.ts` here — the caller (the CLI
- *     generator in #196) is responsible for running the config in
- *     a scratch context and passing the live map to this function.
- *
- *   - Output: a single `.d.ts` file with:
- *       1. Re-exports of `Collection`, `CollectionEntry` types
- *       2. A `CollectionMap` interface keyed by collection name
- *       3. A `CollectionName` union type
- *       4. Per-collection `Entry{Name}` aliases
- *
- *   - Determinism: output order is stable (sorted by collection name)
- *     so regenerating without content changes produces a no-op diff.
- *
- * Schema-level type extraction is intentionally shallow for the MVP —
- * we emit `CollectionEntry<Record<string, unknown>>` for collections
- * without a schema, and `CollectionEntry<z.infer<typeof X>>` only
- * when the user exports the schema alongside the collection. A future
- * pass (tracked in a follow-up) will parse the Zod schema at build
- * time to emit concrete interfaces.
- */
-
-import * as fs from "fs";
-import * as path from "path";
-import type { Collection } from "./collection";
-
-/**
- * Structural view of a Collection accepted by the type emitter. The
- * generator only reads the collection's name — it never calls methods
- * — so the empty interface lets callers pass typed
- * `Collection<{title: string}>` without running into TypeScript's
- * invariance on generic classes.
- */
-// biome-ignore lint/suspicious/noEmptyInterface: marker type for variance
-interface CollectionLike {}
-
-/** Input map: `{ docs: docsCollection, blog: blogCollection }`. */
-export type CollectionRegistry = Record<string, CollectionLike>;
-
-// Re-export the Collection type so users of @mandujs/core/content still
-// see it alongside the registry.
-export type { Collection };
-
-/** Options for the type-emitter. */
-export interface GenerateTypesOptions {
-  /**
-   * Destination path for the generated `.d.ts` file. Defaults to
-   * `.mandu/generated/content-types.d.ts` relative to `root`.
-   */
-  outFile?: string;
-  /**
-   * Project root. Used to resolve `outFile` when that option is
-   * relative. Defaults to `process.cwd()`.
-   */
-  root?: string;
-  /**
-   * Banner comment prepended to the file. Defaults to an
-   * auto-generated warning so authors know not to hand-edit.
-   */
-  banner?: string;
-}
-
-const DEFAULT_BANNER = `/**
- * AUTO-GENERATED by @mandujs/core/content — do not edit by hand.
- * Regenerated on every \`mandu build\` / \`mandu dev\` bootstrap.
- */`;
-
-/**
- * Generate the `content-types.d.ts` source string. Exposed separately
- * from the filesystem writer so tests can assert on the output without
- * touching disk.
- */
-export function renderContentTypes(
-  collections: CollectionRegistry
-): string {
-  const names = Object.keys(collections).sort();
-  const lines: string[] = [];
-  lines.push(DEFAULT_BANNER);
-  lines.push("");
-  lines.push(`import type { Collection, CollectionEntry } from "@mandujs/core/content";`);
-  lines.push("");
-  lines.push("// Per-collection entry aliases");
-  for (const name of names) {
-    // We can't introspect Zod at runtime without an ICU-sized schema
-    // crawler, so we emit `Record<string, unknown>` here. Users who
-    // want full field typing can import their schema directly:
-    //   type DocEntry = CollectionEntry<z.infer<typeof docsSchema>>;
-    lines.push(
-      `export type Entry${capitalize(name)} = CollectionEntry<Record<string, unknown>>;`
-    );
-  }
-  lines.push("");
-  lines.push("export interface CollectionMap {");
-  for (const name of names) {
-    lines.push(`  ${JSON.stringify(name)}: Collection<Record<string, unknown>>;`);
-  }
-  lines.push("}");
-  lines.push("");
-  lines.push(
-    `export type CollectionName = ${names.length > 0 ? names.map((n) => JSON.stringify(n)).join(" | ") : "never"};`
-  );
-  lines.push("");
-  return lines.join("\n");
-}
-
-/**
- * Write the generated types file to disk. Creates the directory
- * tree if necessary and is a no-op if the file already contains the
- * exact same contents (prevents unnecessary filewatcher churn during
- * `mandu dev`).
- */
-export function generateContentTypes(
-  collections: CollectionRegistry,
-  options: GenerateTypesOptions = {}
-): { outFile: string; wrote: boolean } {
-  const root = options.root ?? process.cwd();
-  const outFile = path.isAbsolute(options.outFile ?? "")
-    ? (options.outFile as string)
-    : path.resolve(
-        root,
-        options.outFile ?? ".mandu/generated/content-types.d.ts"
-      );
-  const banner = options.banner ?? DEFAULT_BANNER;
-  const body = renderContentTypes(collections);
-  const content = banner === DEFAULT_BANNER ? body : banner + "\n\n" + body.slice(body.indexOf("\n\n") + 2);
-
-  let existing: string | null = null;
-  try {
-    existing = fs.readFileSync(outFile, "utf8");
-  } catch {
-    existing = null;
-  }
-  if (existing === content) {
-    return { outFile, wrote: false };
-  }
-  fs.mkdirSync(path.dirname(outFile), { recursive: true });
-  fs.writeFileSync(outFile, content, "utf8");
-  return { outFile, wrote: true };
-}
-
-function capitalize(value: string): string {
-  // Collection names might contain dashes/underscores (`my-docs`),
-  // which are not valid identifiers. Strip non-word chars and
-  // PascalCase the remaining segments so `my-docs` becomes `MyDocs`.
-  return value
-    .split(/[^A-Za-z0-9]+/)
-    .filter((part) => part.length > 0)
-    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
-    .join("");
-}
+/**
+ * Content Types Generator (Issue #199)
+ *
+ * Emits `.mandu/generated/content-types.d.ts` with typed aliases for
+ * every collection declared in `content.config.ts`. This gives users
+ * full autocomplete on `docs.all()`, `docs.get(slug)`, etc. without
+ * having to thread generics through every call site:
+ *
+ * ```ts
+ * // user writes
+ * import type { CollectionMap } from '.mandu/generated/content-types';
+ * const entry = (await collections.docs.all())[0];
+ * entry.data.title; // typed as string when schema has title: z.string()
+ * ```
+ *
+ * # Contract
+ *
+ *   - Input: a map of collection-name → Collection instance (already
+ *     returned from `defineCollection({ path, schema })`). We DO NOT
+ *     re-execute `content.config.ts` here — the caller (the CLI
+ *     generator in #196) is responsible for running the config in
+ *     a scratch context and passing the live map to this function.
+ *
+ *   - Output: a single `.d.ts` file with:
+ *       1. Re-exports of `Collection`, `CollectionEntry` types
+ *       2. A `CollectionMap` interface keyed by collection name
+ *       3. A `CollectionName` union type
+ *       4. Per-collection `Entry{Name}` aliases
+ *
+ *   - Determinism: output order is stable (sorted by collection name)
+ *     so regenerating without content changes produces a no-op diff.
+ *
+ * Schema-level type extraction is intentionally shallow for the MVP —
+ * we emit `CollectionEntry<Record<string, unknown>>` for collections
+ * without a schema, and `CollectionEntry<z.infer<typeof X>>` only
+ * when the user exports the schema alongside the collection. A future
+ * pass (tracked in a follow-up) will parse the Zod schema at build
+ * time to emit concrete interfaces.
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import type { Collection } from "./collection";
+
+/**
+ * Structural view of a Collection accepted by the type emitter. The
+ * generator only reads the collection's name — it never calls methods
+ * — so the empty interface lets callers pass typed
+ * `Collection<{title: string}>` without running into TypeScript's
+ * invariance on generic classes.
+ */
+// biome-ignore lint/suspicious/noEmptyInterface: marker type for variance
+interface CollectionLike {}
+
+/** Input map: `{ docs: docsCollection, blog: blogCollection }`. */
+export type CollectionRegistry = Record<string, CollectionLike>;
+
+// Re-export the Collection type so users of @mandujs/core/content still
+// see it alongside the registry.
+export type { Collection };
+
+/** Options for the type-emitter. */
+export interface GenerateTypesOptions {
+  /**
+   * Destination path for the generated `.d.ts` file. Defaults to
+   * `.mandu/generated/content-types.d.ts` relative to `root`.
+   */
+  outFile?: string;
+  /**
+   * Project root. Used to resolve `outFile` when that option is
+   * relative. Defaults to `process.cwd()`.
+   */
+  root?: string;
+  /**
+   * Banner comment prepended to the file. Defaults to an
+   * auto-generated warning so authors know not to hand-edit.
+   */
+  banner?: string;
+}
+
+const DEFAULT_BANNER = `/**
+ * AUTO-GENERATED by @mandujs/core/content — do not edit by hand.
+ * Regenerated on every \`mandu build\` / \`mandu dev\` bootstrap.
+ */`;
+
+/**
+ * Generate the `content-types.d.ts` source string. Exposed separately
+ * from the filesystem writer so tests can assert on the output without
+ * touching disk.
+ */
+export function renderContentTypes(
+  collections: CollectionRegistry
+): string {
+  const names = Object.keys(collections).sort();
+  const lines: string[] = [];
+  lines.push(DEFAULT_BANNER);
+  lines.push("");
+  lines.push(`import type { Collection, CollectionEntry } from "@mandujs/core/content";`);
+  lines.push("");
+  lines.push("// Per-collection entry aliases");
+  for (const name of names) {
+    // We can't introspect Zod at runtime without an ICU-sized schema
+    // crawler, so we emit `Record<string, unknown>` here. Users who
+    // want full field typing can import their schema directly:
+    //   type DocEntry = CollectionEntry<z.infer<typeof docsSchema>>;
+    lines.push(
+      `export type Entry${capitalize(name)} = CollectionEntry<Record<string, unknown>>;`
+    );
+  }
+  lines.push("");
+  lines.push("export interface CollectionMap {");
+  for (const name of names) {
+    lines.push(`  ${JSON.stringify(name)}: Collection<Record<string, unknown>>;`);
+  }
+  lines.push("}");
+  lines.push("");
+  lines.push(
+    `export type CollectionName = ${names.length > 0 ? names.map((n) => JSON.stringify(n)).join(" | ") : "never"};`
+  );
+  lines.push("");
+  return lines.join("\n");
+}
+
+/**
+ * Write the generated types file to disk. Creates the directory
+ * tree if necessary and is a no-op if the file already contains the
+ * exact same contents (prevents unnecessary filewatcher churn during
+ * `mandu dev`).
+ */
+export function generateContentTypes(
+  collections: CollectionRegistry,
+  options: GenerateTypesOptions = {}
+): { outFile: string; wrote: boolean } {
+  const root = options.root ?? process.cwd();
+  const outFile = path.isAbsolute(options.outFile ?? "")
+    ? (options.outFile as string)
+    : path.resolve(
+        root,
+        options.outFile ?? ".mandu/generated/content-types.d.ts"
+      );
+  const banner = options.banner ?? DEFAULT_BANNER;
+  const body = renderContentTypes(collections);
+  const content = banner === DEFAULT_BANNER ? body : banner + "\n\n" + body.slice(body.indexOf("\n\n") + 2);
+
+  let existing: string | null = null;
+  try {
+    existing = fs.readFileSync(outFile, "utf8");
+  } catch {
+    existing = null;
+  }
+  if (existing === content) {
+    return { outFile, wrote: false };
+  }
+  fs.mkdirSync(path.dirname(outFile), { recursive: true });
+  fs.writeFileSync(outFile, content, "utf8");
+  return { outFile, wrote: true };
+}
+
+function capitalize(value: string): string {
+  // Collection names might contain dashes/underscores (`my-docs`),
+  // which are not valid identifiers. Strip non-word chars and
+  // PascalCase the remaining segments so `my-docs` becomes `MyDocs`.
+  return value
+    .split(/[^A-Za-z0-9]+/)
+    .filter((part) => part.length > 0)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join("");
+}

package/src/content/index.ts

@@ -179,7 +179,12 @@ export function defineContentConfig<T extends ContentConfigType>(config: T): T {
 // `./collection.ts` — it detects the shape at runtime via the presence
 // of the `loader` property.
 
-export { defineCollection, Collection } from "./collection";
+export {
+  defineCollection,
+  Collection,
+  getRegisteredCollections,
+  invalidateAllCollections,
+} from "./collection";
 export type {
   CollectionEntry,
   CompiledCollectionEntry,