content-query 0.0.2 → 0.1.0

package/dist/relational-types-DLniKi5S.d.mts

@@ -0,0 +1,245 @@
+import { a as Relationship, i as QueryData, n as CollectionRegistry, o as RelationshipsOf } from "./types-BPh2cBPs.mjs";
+
+//#region src/query/plan.d.ts
+type PredicateOperator = "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "in-array" | "not-in-array" | "contains" | "starts-with" | "ends-with" | "like" | "ilike" | "array-contains" | "array-contains-any" | "array-contains-all" | "array-contained" | "is-null" | "is-undefined" | "is-missing";
+type Expression = {
+  kind: "predicate";
+  operator: PredicateOperator;
+  field: string;
+  value?: unknown;
+} | {
+  kind: "relation";
+  collection: string;
+  field: string;
+  target: string;
+  expression: Expression;
+} | {
+  kind: "and" | "or" | "not";
+  expressions: readonly Expression[];
+};
+type QueryPlan = {
+  collection: string;
+  select?: readonly string[];
+  allFields?: boolean;
+  exclude?: readonly string[];
+  filters: readonly Expression[];
+  order: readonly {
+    field: string;
+    direction: "asc" | "desc";
+  }[];
+  limit?: number;
+  offset?: number;
+  with: Readonly<Record<string, QueryPlan>>;
+  adjacent?: true | QueryPlan;
+};
+type QueryRegistry = Record<string, {
+  relationships: Record<string, Relationship>;
+}>;
+//#endregion
+//#region src/query/types.d.ts
+declare const queryType: unique symbol;
+declare const fieldType: unique symbol;
+type Field$1<Value> = {
+  readonly name: string;
+  readonly [fieldType]: Value;
+};
+type Fields<Data> = { readonly [Name in keyof Data]-?: Field$1<Data[Name]> };
+type Scalar = string | number | bigint | boolean | Date | null | undefined;
+type ScalarField<Value> = Field$1<Value> & ([Value] extends [Scalar] ? unknown : never);
+type Ordered<Value> = NonNullable<Value> extends string ? unknown : NonNullable<Value> extends number ? unknown : NonNullable<Value> extends bigint ? unknown : NonNullable<Value> extends Date ? unknown : never;
+type SortKey<Data> = { [Name in keyof Data]-?: Ordered<Data[Name]> extends never ? NonNullable<Data[Name]> extends boolean ? Name : never : Name }[keyof Data] & string;
+type QueryInfo<Result = unknown, Selected extends boolean = boolean, Filtered extends boolean = boolean> = {
+  readonly [queryType]: {
+    result: Result;
+    selected: Selected;
+    filtered: Filtered;
+  };
+};
+type Simplify$1<Value> = { [Key in keyof Value]: Value[Key] };
+type ResultOf<Configured> = Configured extends QueryInfo<infer Result> ? Result : never;
+type FilteredOf<Configured> = Configured extends QueryInfo<unknown, boolean, infer Filtered> ? Filtered : false;
+type RelationOf<Registry extends CollectionRegistry, Name extends keyof Registry, Key extends keyof RelationshipsOf<Registry[Name]>> = RelationshipsOf<Registry[Name]>[Key] & Relationship;
+type RelatedName$1<Registry extends CollectionRegistry, Relation extends Relationship> = Relation["collection"] & keyof Registry & string;
+/** Applies declared relationship cardinality, optional reference fields, and filtering to a result. */
+type RelationshipResult<Definition, Relation extends Relationship, Result, Filtered extends boolean = false> = Relation["type"] extends "many" ? Result[] : Result | (Filtered extends true ? null : Relation["referenceSide"] extends "from" ? Relation["from"] extends keyof QueryData<Definition> ? null extends QueryData<Definition>[Relation["from"]] ? null : undefined extends QueryData<Definition>[Relation["from"]] ? null : never : null : null);
+type RelationValue<Definition, Relation extends Relationship, Configured> = RelationshipResult<Definition, Relation, ResultOf<Configured>, FilteredOf<Configured>>;
+type Query<Registry extends CollectionRegistry, Name extends keyof Registry & string, Result = {}, Selected extends boolean = false, Many extends boolean = true, Root extends boolean = true, Filtered extends boolean = false, AllowAdjacent extends boolean = true, Pagination extends boolean = true> = QueryInfo<Result, Selected, Filtered> & {
+  select<const Keys extends readonly [keyof QueryData<Registry[Name]> & string, ...(keyof QueryData<Registry[Name]> & string)[]]>(...keys: Keys): Query<Registry, Name, { [Key in Exclude<keyof Result, keyof QueryData<Registry[Name]>> | Keys[number]]: Key extends Keys[number] ? QueryData<Registry[Name]>[Key & keyof QueryData<Registry[Name]>] : Key extends keyof Result ? Result[Key] : never }, true, Many, Root, Filtered, AllowAdjacent, Pagination>;
+  where(configure: (fields: Fields<QueryData<Registry[Name]>>) => Expression): Query<Registry, Name, Result, Selected, Many, Root, true, AllowAdjacent, Pagination>;
+  with<Key extends keyof RelationshipsOf<Registry[Name]> & string, Configured extends QueryInfo<unknown, true>>(name: Key, configure: (query: Query<Registry, RelatedName$1<Registry, RelationOf<Registry, Name, Key>>, {}, false, RelationOf<Registry, Name, Key>["type"] extends "many" ? true : false, false, false, AllowAdjacent>) => Configured): Query<Registry, Name, Result & { [Property in Key]: RelationValue<Registry[Name], RelationOf<Registry, Name, Key>, Configured> }, true, Many, Root, Filtered, AllowAdjacent, Pagination>;
+} & (Many extends true ? {
+  orderBy(field: SortKey<QueryData<Registry[Name]>>, direction?: "asc" | "desc"): Query<Registry, Name, Result, Selected, Many, Root, Filtered, AllowAdjacent, Pagination>;
+} : {}) & (Many extends true ? Pagination extends true ? {
+  limit(value: number): Query<Registry, Name, Result, Selected, Many, Root, Filtered, AllowAdjacent, Pagination>;
+  offset(value: number): Query<Registry, Name, Result, Selected, Many, Root, Filtered, AllowAdjacent, Pagination>;
+} : {} : {}) & (AllowAdjacent extends true ? {
+  selectAdjacent(): Query<Registry, Name, Result & {
+    _adjacent: Adjacent<{
+      id: string;
+    }>;
+  }, true, Many, Root, Filtered, AllowAdjacent, Pagination>;
+  selectAdjacent<Configured extends QueryInfo<unknown, true>>(configure: (siblings: Query<Registry, Name, {}, false, true, false, false, false, false>) => Configured): Query<Registry, Name, Result & {
+    _adjacent: Adjacent<ResultOf<Configured>>;
+  }, true, Many, Root, Filtered, AllowAdjacent, Pagination>;
+  selectAdjacent<const Options extends AdjacentOptions<Registry, Name>>(options: Options & CheckedOptions<Registry, Name, NoInfer<Options>, true, false, false>): Query<Registry, Name, Result & {
+    _adjacent: Adjacent<SelectionResult<Registry, Name, Options["select"]>>;
+  }, true, Many, Root, Filtered, AllowAdjacent, Pagination>;
+} : {}) & (Root extends true ? {
+  all: Selected extends true ? () => Promise<Simplify$1<Result>[]> : never;
+  execute: Selected extends true ? () => Promise<Simplify$1<Result>[]> : never;
+  then: Selected extends true ? Promise<Simplify$1<Result>[]>["then"] : never;
+  first: Selected extends true ? () => Promise<Simplify$1<Result> | undefined> : never;
+  count(): Promise<number>;
+} : {});
+type Adjacent<Entry> = {
+  previous: Entry | null;
+  next: Entry | null;
+};
+type PresenceFilter = {
+  isNull?: boolean;
+  isUndefined?: boolean;
+  isMissing?: boolean;
+};
+type ScalarFilter<Value> = {
+  equals?: Value;
+  not?: Value | ScalarFilter<Value>;
+  in?: readonly Value[];
+  notIn?: readonly Value[];
+} & (Ordered<Value> extends never ? {} : {
+  gt?: NonNullable<Value>;
+  gte?: NonNullable<Value>;
+  lt?: NonNullable<Value>;
+  lte?: NonNullable<Value>;
+}) & (NonNullable<Value> extends string ? {
+  contains?: string;
+  startsWith?: string;
+  endsWith?: string;
+} : {});
+type FieldFilter$1<Value> = PresenceFilter & (NonNullable<Value> extends readonly (infer Item)[] ? Item extends Scalar ? {
+  has?: Item;
+  hasSome?: readonly Item[];
+  hasEvery?: readonly Item[];
+} : {} : [Value] extends [Scalar] ? ScalarFilter<Value> : {});
+type Where<Data> = { [Name in keyof Data]?: [Data[Name]] extends [Scalar] ? Data[Name] | FieldFilter$1<Data[Name]> : FieldFilter$1<Data[Name]> } & {
+  AND?: Where<Data> | readonly Where<Data>[];
+  OR?: readonly Where<Data>[];
+  NOT?: Where<Data> | readonly Where<Data>[];
+};
+type OrderBy<Data> = Partial<Record<SortKey<Data>, "asc" | "desc">>;
+type ObjectScope<Registry extends CollectionRegistry, Name extends keyof Registry & string, Many extends boolean> = {
+  where?: Where<QueryData<Registry[Name]>> | ((fields: Fields<QueryData<Registry[Name]>>) => Expression);
+} & (Many extends true ? {
+  orderBy?: OrderBy<QueryData<Registry[Name]>> | readonly OrderBy<QueryData<Registry[Name]>>[];
+  limit?: number;
+  offset?: number;
+} : {});
+type QueryOptions<Registry extends CollectionRegistry, Name extends keyof Registry & string, Many extends boolean = true, AllowAdjacent extends boolean = true> = ObjectScope<Registry, Name, Many> & {
+  select: Selection<Registry, Name, AllowAdjacent>;
+};
+type AdjacentOptions<Registry extends CollectionRegistry, Name extends keyof Registry & string> = Omit<QueryOptions<Registry, Name, true, false>, "limit" | "offset">;
+type Selection<Registry extends CollectionRegistry, Name extends keyof Registry & string, AllowAdjacent extends boolean = true> = { [Field in keyof QueryData<Registry[Name]>]?: boolean } & { [Key in keyof RelationshipsOf<Registry[Name]>]?: QueryOptions<Registry, RelatedName$1<Registry, RelationOf<Registry, Name, Key>>, RelationOf<Registry, Name, Key>["type"] extends "many" ? true : false, AllowAdjacent> | false } & (AllowAdjacent extends true ? {
+  _adjacent?: true | AdjacentOptions<Registry, Name>;
+} : {});
+type ObjectRelationValue<Registry extends CollectionRegistry, Name extends keyof Registry & string, Key extends keyof RelationshipsOf<Registry[Name]>, Options> = Options extends {
+  select: infer Projection;
+} ? RelationValue<Registry[Name], RelationOf<Registry, Name, Key>, QueryInfo<SelectionResult<Registry, RelatedName$1<Registry, RelationOf<Registry, Name, Key>>, Projection>, true, "where" extends keyof Options ? true : false>> : never;
+type SelectionResult<Registry extends CollectionRegistry, Name extends keyof Registry & string, Projection> = { -readonly [Key in keyof Projection as Projection[Key] extends false | undefined ? never : Key]-?: Key extends "_adjacent" ? Projection[Key] extends true ? Adjacent<{
+  id: string;
+}> : Projection[Key] extends {
+  select: infer Neighbors;
+} ? Adjacent<SelectionResult<Registry, Name, Neighbors>> : never : Key extends keyof RelationshipsOf<Registry[Name]> ? ObjectRelationValue<Registry, Name, Key, Projection[Key]> : Key extends keyof QueryData<Registry[Name]> ? QueryData<Registry[Name]>[Key] : never };
+type CheckedField<Value, Filter> = Filter extends Scalar ? Filter : { [Operator in keyof Filter]: Operator extends keyof FieldFilter$1<Value> ? Operator extends "not" ? CheckedField<Value, Filter[Operator]> : Filter[Operator] : never };
+type CheckedWhereList$1<Data, Filters extends readonly unknown[]> = { [Index in keyof Filters]: CheckedWhere$1<Data, Filters[Index]> };
+type CheckedWhere$1<Data, Filter> = Filter extends ((...arguments_: never[]) => unknown) ? Filter : { [Key in keyof Filter]: Key extends "AND" | "OR" | "NOT" ? Filter[Key] extends readonly unknown[] ? CheckedWhereList$1<Data, Filter[Key]> : CheckedWhere$1<Data, Filter[Key]> : Key extends keyof Data ? CheckedField<Data[Key], Filter[Key]> : never };
+type CheckedSelection<Registry extends CollectionRegistry, Name extends keyof Registry & string, Projection, AllowAdjacent extends boolean> = { [Key in keyof Projection]: Key extends "_adjacent" ? AllowAdjacent extends true ? Projection[Key] extends true ? true : CheckedOptions<Registry, Name, Projection[Key], true, false, false> : never : Key extends keyof RelationshipsOf<Registry[Name]> ? Projection[Key] extends false ? false : CheckedOptions<Registry, RelatedName$1<Registry, RelationOf<Registry, Name, Key>>, Projection[Key], RelationOf<Registry, Name, Key>["type"] extends "many" ? true : false, AllowAdjacent> : Key extends keyof QueryData<Registry[Name]> ? Projection[Key] : never };
+/** Rejects extra properties throughout inferred options, including recursive neighbor projections. */
+type CheckedOptions<Registry extends CollectionRegistry, Name extends keyof Registry & string, Options, Many extends boolean = true, AllowAdjacent extends boolean = true, Pagination extends boolean = true> = { [Key in keyof Options]: Key extends "select" ? CheckedSelection<Registry, Name, Options[Key], AllowAdjacent> : Key extends "where" ? CheckedWhere$1<QueryData<Registry[Name]>, Options[Key]> : Key extends "limit" | "offset" ? Pagination extends true ? Many extends true ? Options[Key] : never : never : Key extends keyof ObjectScope<Registry, Name, Many> ? Options[Key] : never };
+//#endregion
+//#region src/query/relational-types.d.ts
+type RelatedName<Registry extends CollectionRegistry, Name extends keyof Registry, Key extends keyof RelationshipsOf<Registry[Name]>> = (RelationshipsOf<Registry[Name]>[Key] & Relationship)["collection"] & keyof Registry & string;
+type IsMany<Registry extends CollectionRegistry, Name extends keyof Registry, Key extends keyof RelationshipsOf<Registry[Name]>> = RelationshipsOf<Registry[Name]>[Key] extends {
+  type: "many";
+} ? true : false;
+type Condition<Value> = ([Value] extends [Scalar] ? Value : never) | FieldFilter<Value>;
+type FieldFilter<Value> = {
+  isNull?: boolean;
+  isNotNull?: boolean;
+  isUndefined?: boolean;
+  isMissing?: boolean;
+  AND?: readonly Condition<Value>[];
+  OR?: readonly Condition<Value>[];
+  NOT?: Condition<Value>;
+} & ([Value] extends [Scalar] ? {
+  eq?: Value;
+  ne?: Value;
+  in?: readonly Value[];
+  notIn?: readonly Value[];
+} : {}) & (Ordered<Value> extends never ? {} : {
+  gt?: NonNullable<Value>;
+  gte?: NonNullable<Value>;
+  lt?: NonNullable<Value>;
+  lte?: NonNullable<Value>;
+}) & (NonNullable<Value> extends string ? {
+  like?: string;
+  ilike?: string;
+  notLike?: string;
+  notIlike?: string;
+  contains?: string;
+  startsWith?: string;
+  endsWith?: string;
+} : {}) & (NonNullable<Value> extends readonly (infer Item)[] ? Item extends Scalar ? {
+  arrayContains?: readonly Item[];
+  arrayOverlaps?: readonly Item[];
+  arrayContained?: readonly Item[];
+} : {} : {});
+/** Object predicates over prepared fields and existential filters over related entries. */
+type RelationalWhere<Registry extends CollectionRegistry, Name extends keyof Registry & string> = { [Key in keyof QueryData<Registry[Name]>]?: Condition<QueryData<Registry[Name]>[Key]> } & { [Key in keyof RelationshipsOf<Registry[Name]>]?: boolean | RelationalWhere<Registry, RelatedName<Registry, Name, Key>> } & {
+  AND?: RelationalWhere<Registry, Name> | readonly RelationalWhere<Registry, Name>[];
+  OR?: readonly RelationalWhere<Registry, Name>[];
+  NOT?: RelationalWhere<Registry, Name> | readonly RelationalWhere<Registry, Name>[];
+  RAW?: (fields: Fields<QueryData<Registry[Name]>>) => Expression;
+};
+/** Collection-scoped metadata queries with Drizzle-style columns, relationships, and filters. */
+type RelationalQueryOptions<Registry extends CollectionRegistry, Name extends keyof Registry & string, Many extends boolean = true, AllowAdjacent extends boolean = true, Pagination extends boolean = true> = {
+  columns?: Partial<Record<keyof QueryData<Registry[Name]>, boolean>>;
+  where?: RelationalWhere<Registry, Name>;
+  with?: { [Key in keyof RelationshipsOf<Registry[Name]>]?: boolean | RelationalQueryOptions<Registry, RelatedName<Registry, Name, Key>, IsMany<Registry, Name, Key>, AllowAdjacent> };
+} & (Many extends true ? {
+  orderBy?: OrderBy<QueryData<Registry[Name]>>;
+} : {}) & (Many extends true ? (Pagination extends true ? {
+  limit?: number;
+  offset?: number;
+} : {}) : {}) & (AllowAdjacent extends true ? {
+  adjacent?: true | RelationalQueryOptions<Registry, Name, true, false, false>;
+} : {});
+/** Options accepted by the root count helper, whose result ignores sorting and pagination. */
+type RelationalCountOptions<Registry extends CollectionRegistry, Name extends keyof Registry & string> = Pick<RelationalQueryOptions<Registry, Name>, "where" | "orderBy" | "offset" | "limit">;
+type ColumnResult<Data, Options> = Options extends {
+  columns: infer Columns;
+} ? keyof Columns extends never ? {} : true extends Columns[keyof Columns] ? { -readonly [Key in keyof Columns as Columns[Key] extends false | undefined ? never : Key]-?: Key extends keyof Data ? Data[Key] : never } : Omit<Data, { [Key in keyof Columns]: Columns[Key] extends false ? Key : never }[keyof Columns]> : Data;
+type IncludedResult<Registry extends CollectionRegistry, Name extends keyof Registry & string, Options> = Options extends {
+  with: infer Related;
+} ? { -readonly [Key in keyof Related as Related[Key] extends false | undefined ? never : Key]-?: Key extends keyof RelationshipsOf<Registry[Name]> ? RelationshipResult<Registry[Name], RelationshipsOf<Registry[Name]>[Key] & Relationship, RelationalQueryResult<Registry, RelatedName<Registry, Name, Key>, Related[Key] extends true ? {} : Related[Key]>, "where" extends keyof Related[Key] ? true : false> : never } : {};
+type AdjacentResult<Registry extends CollectionRegistry, Name extends keyof Registry & string, Options> = Options extends {
+  adjacent: infer Neighbors;
+} ? {
+  _adjacent: Neighbors extends true ? Adjacent<{
+    id: string;
+  }> : Adjacent<RelationalQueryResult<Registry, Name, Neighbors>>;
+} : {};
+type Simplify<Value> = { [Key in keyof Value]: Value[Key] };
+/** Infers selected columns and relationships, preserving optional metadata in default projections. */
+type RelationalQueryResult<Registry extends CollectionRegistry, Name extends keyof Registry & string, Options> = Options extends unknown ? Simplify<ColumnResult<QueryData<Registry[Name]>, Options> & IncludedResult<Registry, Name, Options> & AdjacentResult<Registry, Name, Options>> : never;
+type CheckedConditions<Value, Filters extends readonly unknown[]> = { [Index in keyof Filters]: CheckedCondition<Value, Filters[Index]> };
+type CheckedCondition<Value, Filter> = Filter extends Scalar ? Filter : { [Key in keyof Filter]: Key extends "AND" | "OR" ? Filter[Key] extends readonly unknown[] ? CheckedConditions<Value, Filter[Key]> : never : Key extends "NOT" ? CheckedCondition<Value, Filter[Key]> : Key extends keyof FieldFilter<Value> ? Filter[Key] : never };
+type CheckedWhereList<Registry extends CollectionRegistry, Name extends keyof Registry & string, Filters extends readonly unknown[]> = { [Index in keyof Filters]: CheckedWhere<Registry, Name, Filters[Index]> };
+type CheckedWhere<Registry extends CollectionRegistry, Name extends keyof Registry & string, Filter> = { [Key in keyof Filter]: Key extends "AND" | "OR" | "NOT" ? Filter[Key] extends readonly unknown[] ? CheckedWhereList<Registry, Name, Filter[Key]> : CheckedWhere<Registry, Name, Filter[Key]> : Key extends "RAW" ? Filter[Key] : Key extends keyof RelationshipsOf<Registry[Name]> ? Filter[Key] extends boolean ? Filter[Key] : CheckedWhere<Registry, RelatedName<Registry, Name, Key>, Filter[Key]> : Key extends keyof QueryData<Registry[Name]> ? CheckedCondition<QueryData<Registry[Name]>[Key], Filter[Key]> : never };
+/** Rejects unknown options recursively, including options supplied through inferred variables. */
+type CheckedRelationalOptions<Registry extends CollectionRegistry, Name extends keyof Registry & string, Options, Many extends boolean = true, AllowAdjacent extends boolean = true, Pagination extends boolean = true> = { [Key in keyof Options]: Key extends "columns" ? { [Column in keyof Options[Key]]: Column extends keyof QueryData<Registry[Name]> ? Options[Key][Column] : never } : Key extends "where" ? CheckedWhere<Registry, Name, Options[Key]> : Key extends "with" ? { [Related in keyof Options[Key]]: Related extends keyof RelationshipsOf<Registry[Name]> ? Options[Key][Related] extends boolean ? Options[Key][Related] : CheckedRelationalOptions<Registry, RelatedName<Registry, Name, Related>, Options[Key][Related], IsMany<Registry, Name, Related>, AllowAdjacent> : never } : Key extends "adjacent" ? AllowAdjacent extends true ? Options[Key] extends true ? true : CheckedRelationalOptions<Registry, Name, Options[Key], true, false, false> : never : Key extends "orderBy" ? Key extends keyof RelationalQueryOptions<Registry, Name, Many, AllowAdjacent, Pagination> ? { [Field in keyof Options[Key]]: Field extends keyof OrderBy<QueryData<Registry[Name]>> ? Options[Key][Field] : never } : never : Key extends keyof RelationalQueryOptions<Registry, Name, Many, AllowAdjacent, Pagination> ? Options[Key] : never };
+/** Typed per-collection query entry points that never expose source configuration at runtime. */
+type RelationalQueries<Registry extends CollectionRegistry> = string extends keyof Registry ? {} : { readonly [Name in keyof Registry & string]: {
+  /** Returns matching metadata rows and requested relationships. */findMany<const Options extends RelationalQueryOptions<Registry, Name> = {}>(options?: Options & CheckedRelationalOptions<Registry, Name, NoInfer<Options>>): Promise<RelationalQueryResult<Registry, Name, Options>[]>; /** Returns the first matching entry, or undefined when none matches. */
+  findFirst<const Options extends RelationalQueryOptions<Registry, Name> = {}>(options?: Options & CheckedRelationalOptions<Registry, Name, NoInfer<Options>>): Promise<RelationalQueryResult<Registry, Name, Options> | undefined>;
+} };
+//#endregion
+export { QueryPlan as _, RelationalWhere as a, Fields as c, Scalar as d, ScalarField as f, Expression as g, Where as h, RelationalQueryResult as i, Ordered as l, SelectionResult as m, RelationalQueries as n, Adjacent as o, Selection as p, RelationalQueryOptions as r, Field$1 as s, RelationalCountOptions as t, Query as u, QueryRegistry as v };

package/dist/runtime.d.mts

@@ -0,0 +1,3 @@
+import { n as ContentRenderResult, t as ContentHeading } from "./types-DcvHRmxO.mjs";
+import { a as ContentError, i as ContentDiagnostic, o as ContentErrorCode, t as Content } from "./content-Crag1Uch.mjs";
+export { type Content, type ContentDiagnostic, ContentError, type ContentErrorCode, type ContentHeading, type ContentRenderResult };

package/dist/runtime.mjs

@@ -0,0 +1,6 @@
+import { t as ContentError } from "./errors-C8lWyiy2.mjs";
+import { t as assertServerOnly } from "./server-only-CIE-FHx0.mjs";
+//#region src/runtime.ts
+assertServerOnly();
+//#endregion
+export { ContentError };

package/dist/schema-CnCbMosm.mjs

@@ -0,0 +1,20 @@
+import { n as __exportAll } from "./chunk-CJs4Fogs.mjs";
+import { array, bigint, boolean, coerce, date, enum as enum$1, literal, number, object, record, string, union, unknown } from "zod";
+//#region src/schema/builders.ts
+var builders_exports = /* @__PURE__ */ __exportAll({
+	array: () => array,
+	bigint: () => bigint,
+	boolean: () => boolean,
+	coerce: () => coerce,
+	date: () => date,
+	enum: () => enum$1,
+	literal: () => literal,
+	number: () => number,
+	object: () => object,
+	record: () => record,
+	string: () => string,
+	union: () => union,
+	unknown: () => unknown
+});
+//#endregion
+export { number as n, string as r, builders_exports as t };

package/dist/schema.d.mts

@@ -0,0 +1,13 @@
+import { array, bigint, boolean, coerce, date, enum as enum$1, literal, number, object, record, string, union, unknown } from "zod";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/schema/builders.d.ts
+declare namespace builders_d_exports {
+  export { array, bigint, boolean, coerce, date, enum$1 as enum, output as infer, input, literal, number, object, output, record, string, union, unknown };
+}
+/** Infers the input type of any Standard Schema V1 validator. */
+type input<Validator extends StandardSchemaV1> = StandardSchemaV1.InferInput<Validator>;
+/** Infers the validated output type of any Standard Schema V1 validator. */
+type output<Validator extends StandardSchemaV1> = StandardSchemaV1.InferOutput<Validator>;
+//#endregion
+export { builders_d_exports as schema };

package/dist/schema.mjs

@@ -0,0 +1,2 @@
+import { t as builders_exports } from "./schema-CnCbMosm.mjs";
+export { builders_exports as schema };

package/dist/server-only-CIE-FHx0.mjs

@@ -0,0 +1,7 @@
+//#region src/shared/server-only.ts
+/** Provides a fallback when a host has not rejected a server import during bundling. */
+function assertServerOnly() {
+	if (globalThis.window !== void 0) throw new Error("[content-query] Content querying and preparation are server-only.");
+}
+//#endregion
+export { assertServerOnly as t };

package/dist/types-BPh2cBPs.d.mts

@@ -0,0 +1,48 @@
+import { a as Loader } from "./types-hmDOw87q.mjs";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/collection/types.d.ts
+type Schema = StandardSchemaV1;
+type SchemaOutput<Value> = Value extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<Value> : Record<string, unknown>;
+type ComputedContext<Data, Source = unknown> = {
+  /** The collection's key in the configured registry. */collection: string;
+  id: string; /** Loader-provided source metadata, detached from stored entries for this resolver. */
+  source?: Source extends object ? Readonly<Source> : Source;
+  data: Readonly<Data>;
+  readBody(this: void): Promise<string | undefined>;
+  signal: AbortSignal;
+};
+type ComputedDefinition<Data = Record<string, unknown>, Source = unknown> = {
+  schema: Schema;
+  resolve(context: ComputedContext<Data, Source>): unknown;
+};
+type Relationship = {
+  collection: string;
+  type: "one" | "many";
+  from: string;
+  to: string;
+  referenceSide: "from" | "to" | "none";
+};
+type CollectionDefinition<SourceSchema extends Schema | undefined = Schema | undefined, Computed extends Record<string, ComputedDefinition<never, never>> = Record<string, ComputedDefinition<never, never>>, Relationships extends Record<string, Relationship> = Record<string, Relationship>> = {
+  loader: Loader;
+  schema?: SourceSchema;
+  computed?: Computed;
+  relationships?: Relationships;
+};
+type CollectionRegistry = Record<string, CollectionDefinition>;
+type EntryData<Definition> = Definition extends {
+  schema: infer SourceSchema;
+} ? SchemaOutput<SourceSchema> : Record<string, unknown>;
+type ComputedData<Definition> = Definition extends {
+  computed: infer Computed;
+} ? { [Name in keyof Computed]: Computed[Name] extends {
+  schema: infer ResultSchema;
+} ? SchemaOutput<ResultSchema> : never } : {};
+type QueryData<Definition> = {
+  id: string;
+} & EntryData<Definition> & ComputedData<Definition>;
+type RelationshipsOf<Definition> = Definition extends {
+  relationships: infer Relationships;
+} ? Relationships : {};
+//#endregion
+export { Relationship as a, SchemaOutput as c, QueryData as i, CollectionRegistry as n, RelationshipsOf as o, ComputedContext as r, Schema as s, CollectionDefinition as t };

package/dist/types-DcvHRmxO.d.mts

@@ -0,0 +1,20 @@
+//#region src/runtime/types.d.ts
+type ContentHeading = {
+  depth: number;
+  slug: string;
+  text: string;
+};
+type ContentRenderResult = {
+  html: string;
+  headings: ContentHeading[];
+};
+type RenderedContent = {
+  html: string;
+  metadata?: {
+    headings?: ContentHeading[];
+    imagePaths?: string[];
+    [key: string]: unknown;
+  };
+};
+//#endregion
+export { ContentRenderResult as n, RenderedContent as r, ContentHeading as t };

package/dist/types-hmDOw87q.d.mts

@@ -0,0 +1,135 @@
+import { r as RenderedContent } from "./types-DcvHRmxO.mjs";
+
+//#region src/shared/types.d.ts
+type MaybePromise<Value> = Value | Promise<Value>;
+//#endregion
+//#region src/loaders/types.d.ts
+declare const loaderSourceType: unique symbol;
+/** A stored content record, following Astro's build-time DataEntry contract. */
+type DataEntry<Data extends Record<string, unknown> = Record<string, unknown>, Source = unknown> = {
+  id: string;
+  data: Data;
+  body?: string;
+  rendered?: RenderedContent;
+  filePath?: string;
+  digest?: string | number;
+  deferredRender?: boolean;
+  assetImports?: string[];
+  imageImports?: (string | number)[][]; /** Optional ContentQuery metadata; Astro stores do not retain this extension. */
+  source?: Source;
+};
+/** Source metadata supplied by loaders of individual local files. */
+type FileSource = {
+  filePath: string;
+};
+/** Source metadata identifying a record within a shared local file. */
+type FileEntrySource = FileSource & {
+  key: string;
+};
+type DataStore<in Source = unknown> = {
+  get<Data extends Record<string, unknown> = Record<string, unknown>>(key: string): DataEntry<Data> | undefined;
+  set<Data extends Record<string, unknown>>(entry: DataEntry<Data, Source>): boolean;
+  entries(): [string, DataEntry][];
+  values(): DataEntry[];
+  keys(): string[];
+  has(key: string): boolean;
+  delete(key: string): void;
+  clear(): void;
+  addModuleImport(filename: string): void;
+};
+type MetaStore = {
+  get(key: string): string | undefined;
+  set(key: string, value: string): void;
+  has(key: string): boolean;
+  delete(key: string): void;
+};
+type LoaderConfig = {
+  root: URL;
+  srcDir: URL;
+  publicDir: URL;
+  outDir: URL;
+  cacheDir: URL;
+  base: string;
+  site?: string;
+  output: "static" | "server" | "hybrid";
+};
+type LoaderLogger = {
+  label: string;
+  options: {
+    level: "debug" | "info" | "warn" | "error" | "silent";
+    destination: {
+      write(message: {
+        label: string | null;
+        level: "debug" | "info" | "warn" | "error" | "silent";
+        message: string;
+        newLine: boolean;
+      }): void;
+      flush?(): void | Promise<void>;
+      close?(): void | Promise<void>;
+    };
+  };
+  info(message: string): void;
+  warn(message: string): void;
+  error(message: string): void;
+  debug(message: string): void;
+  fork(label: string): LoaderLogger;
+  flush(): void;
+  close(): void;
+};
+type LoaderWatchEvents = {
+  add: [filename: string];
+  change: [filename: string];
+  unlink: [filename: string];
+  addDir: [filename: string];
+  unlinkDir: [filename: string];
+  all: [event: string, filename: string];
+  error: [cause: Error];
+  ready: [];
+};
+/** Shared filesystem watcher; loader callbacks are serialized and published as complete batches. */
+interface LoaderWatcher {
+  on<Event extends keyof LoaderWatchEvents>(event: Event, listener: (...arguments_: LoaderWatchEvents[Event]) => unknown): LoaderWatcher;
+  once<Event extends keyof LoaderWatchEvents>(event: Event, listener: (...arguments_: LoaderWatchEvents[Event]) => unknown): LoaderWatcher;
+  off<Event extends keyof LoaderWatchEvents>(event: Event, listener: (...arguments_: LoaderWatchEvents[Event]) => unknown): LoaderWatcher;
+  removeListener<Event extends keyof LoaderWatchEvents>(event: Event, listener: (...arguments_: LoaderWatchEvents[Event]) => unknown): LoaderWatcher;
+  removeAllListeners(event?: string): LoaderWatcher;
+  add(paths: string | readonly string[]): LoaderWatcher;
+  unwatch(paths: string | readonly string[]): LoaderWatcher;
+  close(): Promise<void>;
+}
+type LoaderContext<in Source = unknown> = {
+  collection: string;
+  store: DataStore<Source>;
+  meta: MetaStore;
+  config: LoaderConfig;
+  logger: LoaderLogger;
+  watcher?: LoaderWatcher; /** ContentQuery extension: cancellation for this load attempt. */
+  signal?: AbortSignal;
+  parseData<Data extends Record<string, unknown>>(options: {
+    id: string;
+    data: Data;
+    filePath?: string;
+  }): Promise<Data>;
+  renderMarkdown(content: string, options?: {
+    fileURL?: URL;
+  }): Promise<RenderedContent>;
+  generateDigest(data: Record<string, unknown> | string): string;
+  refreshContextData?: Record<string, unknown>;
+};
+/** An Astro-compatible, named build-time content loader. */
+type Loader<out Source = unknown> = {
+  /** Type-only marker preserving metadata inference without changing Astro's load signature. */readonly [loaderSourceType]?: Source;
+  name: string;
+  schema?: unknown;
+  createSchema?(): MaybePromise<{
+    schema: unknown;
+    types?: string;
+  }>;
+  load(context: LoaderContext<Source>): Promise<void>;
+};
+/** Infers the source metadata a typed loader supplies to computed resolvers. */
+type LoaderSource<Value> = Value extends {
+  readonly [loaderSourceType]?: infer Source;
+} ? Source : unknown;
+//#endregion
+export { Loader as a, LoaderLogger as c, MetaStore as d, MaybePromise as f, FileSource as i, LoaderSource as l, DataStore as n, LoaderConfig as o, FileEntrySource as r, LoaderContext as s, DataEntry as t, LoaderWatcher as u };

package/dist/validation-BvvjSUFc.mjs

@@ -0,0 +1,84 @@
+import { n as contentError, t as ContentError } from "./errors-C8lWyiy2.mjs";
+import { i as detach } from "./values-B7lo_2_x.mjs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/loaders/descriptor.ts
+const builtinSymbol = Symbol.for("content-query.builtin-loader");
+/** Finds library-owned loader settings without depending on module instance identity. */
+function builtinLoader(loader) {
+	return loader[builtinSymbol];
+}
+/** Resolves a loader's watch root from the application root, including file URLs. */
+function builtinPath(descriptor, root) {
+	if (descriptor.kind === "file") return path.resolve(root, descriptor.filename);
+	return descriptor.options.base instanceof URL ? path.resolve(fileURLToPath(descriptor.options.base)) : path.resolve(root, descriptor.options.base ?? ".");
+}
+//#endregion
+//#region src/preparation/validation.ts
+/** Checks records independently from validation-provider schema introspection. */
+function isRecord(value) {
+	return !!value && typeof value === "object" && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+}
+/** Validates one result, retaining structured provider issues and their original detail. */
+async function validate(schema, value, context) {
+	if (!schema) return value;
+	try {
+		const result = await schema["~standard"].validate(value);
+		if (result.issues) {
+			const firstPath = result.issues[0]?.path?.map((segment) => typeof segment === "object" ? segment.key : segment);
+			throw new ContentError({
+				...context,
+				code: "validation-error",
+				message: result.issues.map((issue) => issue.message).join("; "),
+				issues: result.issues,
+				path: [...context.path ?? [], ...firstPath ?? []]
+			});
+		}
+		return result.value;
+	} catch (cause) {
+		throw contentError(cause, {
+			...context,
+			code: "validation-error",
+			message: "Schema validation failed."
+		});
+	}
+}
+/** Checks loader transport structure and rejects duplicate snapshot/upsert identities. */
+function normalizeSnapshot(entries, collection) {
+	if (!Array.isArray(entries)) throw new ContentError({
+		code: "source-error",
+		collection,
+		message: "load() must return an array of structured entries."
+	});
+	const snapshot = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		if (!entry || typeof entry.id !== "string" || !entry.id || !isRecord(entry.data) || entry.body !== void 0 && typeof entry.body !== "string" || entry.source !== void 0 && typeof entry.source !== "string") throw new ContentError({
+			code: "source-error",
+			collection,
+			id: entry && typeof entry === "object" && typeof entry.id === "string" ? entry.id : void 0,
+			source: entry && typeof entry === "object" && typeof entry.source === "string" ? entry.source : void 0,
+			message: "Invalid structured loader entry."
+		});
+		if (snapshot.has(entry.id)) throw new ContentError({
+			code: "duplicate-id",
+			collection,
+			id: entry.id,
+			source: entry.source,
+			message: `Duplicate entry ID "${entry.id}".`
+		});
+		snapshot.set(entry.id, entry);
+	}
+	return snapshot;
+}
+/** Validates supplied rendering data and normalizes omitted headings. */
+function renderedPayload(entry) {
+	if (entry.rendered === void 0) return;
+	const rendered = entry.rendered;
+	if (!rendered || typeof rendered.html !== "string" || rendered.metadata !== void 0 && (!isRecord(rendered.metadata) || rendered.metadata.headings !== void 0 && (!Array.isArray(rendered.metadata.headings) || rendered.metadata.headings.some((heading) => !heading || !Number.isInteger(heading.depth) || heading.depth < 1 || heading.depth > 6 || typeof heading.slug !== "string" || typeof heading.text !== "string")))) throw new Error("Invalid supplied HTML/headings payload.");
+	return {
+		html: rendered.html,
+		headings: detach(rendered.metadata?.headings ?? [])
+	};
+}
+//#endregion
+export { builtinLoader as a, validate as i, normalizeSnapshot as n, builtinPath as o, renderedPayload as r, builtinSymbol as s, isRecord as t };