@content-collections/core 0.6.4 → 0.7.1

package/README.md

@@ -28,7 +28,7 @@ Content Collections offers a variety of adapters that seamlessly integrate with
 - [Qwik](https://www.content-collections.dev/docs/quickstart/qwik)
 - [Remix (Vite)](https://www.content-collections.dev/docs/quickstart/remix-vite)
 - [Solid Start](https://www.content-collections.dev/docs/quickstart/solid)
-- [Svelte Kit](https://www.content-collections.dev/docs/quickstart/svelte-kit)
+- [SvelteKit](https://www.content-collections.dev/docs/quickstart/svelte-kit)
 - [Vite](https://www.content-collections.dev/docs/quickstart/vite)
 
 If your framework is not listed, you can still use Content Collections by using the [CLI](https://www.content-collections.dev/docs/quickstart/cli). Please open a ticket if you want to see your framework listed.

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 import z__default, { ZodRawShape, z as z$1, ZodObject, ZodTypeAny, ZodString } from 'zod';
 export * from 'zod';
 
+type CacheFn = <TInput, TOutput>(input: TInput, compute: (input: TInput) => Promise<TOutput> | TOutput) => Promise<TOutput>;
+
 type Parsers = typeof parsers;
 type Parser = keyof typeof parsers;
 declare function parseYaml(content: string): any;
@@ -14,7 +16,7 @@ declare const parsers: {
     };
     readonly json: {
         readonly hasContent: false;
-        readonly parse: (text: string, reviver?: ((this: any, key: string, value: any) => any) | undefined) => any;
+        readonly parse: (text: string, reviver?: (this: any, key: string, value: any) => any) => any;
     };
     readonly yaml: {
         readonly hasContent: false;
@@ -22,8 +24,6 @@ declare const parsers: {
     };
 };
 
-type CacheFn = <TInput, TOutput>(input: TInput, compute: (input: TInput) => Promise<TOutput> | TOutput) => Promise<TOutput>;
-
 declare const literalSchema: z__default.ZodUnion<[z__default.ZodString, z__default.ZodNumber, z__default.ZodBoolean, z__default.ZodNull, z__default.ZodUndefined, z__default.ZodDate, z__default.ZodMap<z__default.ZodUnknown, z__default.ZodUnknown>, z__default.ZodSet<z__default.ZodUnknown>, z__default.ZodBigInt]>;
 type Literal = z__default.infer<typeof literalSchema>;
 type SchemaType = Literal | {
@@ -54,12 +54,13 @@ type GetShape<TParser extends Parser | undefined, TShape extends ZodRawShape> =
 type Schema<TParser extends Parser | undefined, TShape extends ZodRawShape> = z$1.infer<ZodObject<GetShape<TParser, TShape>>> & {
     _meta: Meta;
 };
-type Context = {
+type Context<TSchema = unknown> = {
     documents<TCollection extends AnyCollection>(collection: TCollection): Array<Schema<TCollection["parser"], TCollection["schema"]>>;
     cache: CacheFn;
     collection: {
         name: string;
         directory: string;
+        documents: () => Promise<Array<TSchema>>;
     };
 };
 type Z = typeof z$1;
@@ -68,7 +69,7 @@ type CollectionRequest<TName extends string, TShape extends ZodRawShape, TParser
     parser?: TParser;
     typeName?: string;
     schema: (z: Z) => TShape;
-    transform?: (data: TSchema, context: Context) => TTransformResult;
+    transform?: (data: TSchema, context: Context<TSchema>) => TTransformResult;
     directory: string;
     include: string | string[];
     exclude?: string | string[];
@@ -150,12 +151,31 @@ declare class TransformError extends Error {
 }
 
 type WatcherEvents = {
-    "watcher:file-changed": {
-        filePath: string;
-        modification: Modification;
+    "watcher:subscribe-error": {
+        paths: Array<string>;
+        error: Error;
+    };
+    "watcher:subscribed": {
+        paths: Array<string>;
     };
+    "watcher:unsubscribed": {
+        paths: Array<string>;
+    };
+};
+type SyncFn = (modification: Modification, path: string) => Promise<unknown>;
+type WatchableCollection = {
+    directory: string;
+};
+type WatcherConfiguration = {
+    inputPaths: Array<string>;
+    collections: Array<WatchableCollection>;
 };
+declare function createWatcher(emitter: Emitter, baseDirectory: string, configuration: WatcherConfiguration, sync: SyncFn): Promise<{
+    unsubscribe: () => Promise<void>;
+}>;
+type Watcher = Awaited<ReturnType<typeof createWatcher>>;
 
+type EventMap = Record<string, object>;
 type EventWithError = {
     error: Error;
 };
@@ -168,6 +188,16 @@ type SystemEvents = {
     _error: ErrorEvent;
     _all: SystemEvent;
 };
+type Keys<TEvents extends EventMap> = keyof TEvents & string;
+type Listener<TEvent> = (event: TEvent) => void;
+declare function createEmitter<TEvents extends EventMap>(): {
+    on: {
+        <TKey extends Keys<TEvents>>(key: TKey, listener: Listener<TEvents[TKey]>): void;
+        <TKey extends Keys<SystemEvents>>(key: TKey, listener: Listener<SystemEvents[TKey]>): void;
+    };
+    emit: <TKey extends Keys<TEvents>>(key: TKey, event: TEvents[TKey]) => void;
+};
+type Emitter = ReturnType<typeof createEmitter<Events>>;
 
 type ErrorType = "Read" | "Compile";
 declare class ConfigurationError extends Error {
@@ -179,29 +209,56 @@ type Options$1 = {
     cacheDir?: string;
 };
 
-type BuilderEvents = {
+type BuildEvents = {
     "builder:start": {
         startedAt: number;
     };
     "builder:end": {
         startedAt: number;
         endedAt: number;
+        stats: {
+            collections: number;
+            documents: number;
+        };
+    };
+};
+
+type BuilderEvents = BuildEvents & {
+    "builder:created": {
+        createdAt: number;
+        configurationPath: string;
+        outputDirectory: string;
+    };
+    "watcher:file-changed": {
+        filePath: string;
+        modification: Modification;
+    };
+    "watcher:config-changed": {
+        filePath: string;
+        modification: Modification;
+    };
+    "watcher:config-reload-error": {
+        error: Error;
+        configurationPath: string;
     };
 };
 type Options = Options$1 & {
     outputDir?: string;
 };
-declare function createBuilder(configurationPath: string, options?: Options): Promise<{
-    sync: (modification: Modification, filePath: string) => Promise<boolean>;
+declare class ConfigurationReloadError extends Error {
+    constructor(message: string);
+}
+declare function createBuilder(configurationPath: string, options?: Options, emitter?: Emitter): Promise<{
     build: () => Promise<void>;
+    sync: (modification: Modification, filePath: string) => Promise<boolean>;
     watch: () => Promise<{
         unsubscribe: () => Promise<void>;
     }>;
     on: {
-        <TKey extends "builder:start" | "builder:end" | "collector:read-error" | "collector:parse-error" | "transformer:validation-error" | "transformer:result-error" | "transformer:error" | "watcher:file-changed">(key: TKey, listener: (event: Events[TKey]) => void): void;
-        <TKey_1 extends "_error" | "_all">(key: TKey_1, listener: (event: SystemEvents[TKey_1]) => void): void;
+        <TKey extends "builder:start" | "builder:end" | "builder:created" | "watcher:file-changed" | "watcher:config-changed" | "watcher:config-reload-error" | "collector:read-error" | "collector:parse-error" | "transformer:validation-error" | "transformer:result-error" | "transformer:error" | "watcher:subscribe-error" | "watcher:subscribed" | "watcher:unsubscribed">(key: TKey, listener: (event: Events[TKey]) => void): void;
+        <TKey extends "_error" | "_all">(key: TKey, listener: (event: SystemEvents[TKey]) => void): void;
     };
 }>;
 type Builder = Awaited<ReturnType<typeof createBuilder>>;
 
-export { type AnyCollection, type AnyConfiguration, type Builder, type BuilderEvents, CollectError, type Collection, type CollectionRequest, type Configuration, ConfigurationError, type Context, type Document, type GetTypeByName, type Meta, type Modification, type Schema, TransformError, createBuilder, defineCollection, defineConfig };
+export { type AnyCollection, type AnyConfiguration, type Builder, type BuilderEvents, CollectError, type Collection, type CollectionRequest, type Configuration, ConfigurationError, ConfigurationReloadError, type Context, type Document, type GetTypeByName, type Meta, type Modification, type Schema, TransformError, type Watcher, createBuilder, defineCollection, defineConfig };