@vexcms/core 0.0.19 → 0.1.0-alpha.2

package/dist/collections/validator.d.ts

@@ -0,0 +1,73 @@
+import { CollectionConfig } from "./types";
+import type { VexConfig } from "../config";
+/**
+ * Describes a relationship field in another collection that points to a given collection.
+ *
+ * Used by `collectionConfigToVexSchema` to detect whether a search index should be
+ * auto-generated on the current collection's `useAsTitle` field.
+ *
+ * @see {@link getIncomingRelationships}
+ */
+export interface IncomingRelationship {
+    /** The slug of the collection that holds the relationship field. */
+    fromSlug: string;
+    /** The field key of the relationship field in that collection. */
+    fieldKey: string;
+}
+/**
+ * Returns all relationship fields in other collections that point to `collection`.
+ *
+ * Iterates every collection in `config` (excluding `collection` itself) and collects
+ * any field with `type === "relationship"` whose `collection` matches
+ * `props.collection.slug`.
+ *
+ * @param props - Input props.
+ * @param props.collection - The collection being checked for incoming relationships.
+ * @param props.config - The full resolved VexCMS configuration.
+ * @returns An array of `IncomingRelationship` descriptors, empty if none found.
+ *
+ * @example
+ * ```ts
+ * // posts has: author: relationship({ collection: "authors" })
+ * getIncomingRelationships({ collection: authorsCollection, config })
+ * // → [{ fromSlug: "posts", fieldKey: "author" }]
+ */
+export declare function getIncomingRelationships(props: {
+    collection: CollectionConfig;
+    config: VexConfig;
+}): IncomingRelationship[];
+/**
+ * Converts a resolved `CollectionConfig` to a Convex `defineTable(...)` source string.
+ *
+ * Iterates the collection's fields, builds each field's Convex validator via
+ * `adminFieldToValidator`, and appends index chains:
+ * - `.index()` for fields with an explicit `field.index` property
+ * - `.index("by_<fieldKey>", ["<fieldKey>"])` auto-generated for every relationship field
+ * - `.searchIndex()` for text fields with `field.searchIndex` configured
+ * - `.searchIndex("search_<useAsTitle>", { searchField: "<useAsTitle>", filterFields: [] })`
+ *   auto-generated when another collection has a relationship pointing HERE and
+ *   `useAsTitle` is not a Convex system field (`_id`, `_creationTime`), provided
+ *   no manually configured search index already has that name.
+ *
+ * @param props - Input props.
+ * @param props.collection - The resolved collection definition to convert.
+ * @param props.config - The full resolved VexCMS config, needed for cross-collection relationship detection.
+ * @returns A TypeScript source string declaring the Convex table.
+ *
+ * @example
+ * ```ts
+ * const posts = defineCollection({
+ *   slug: "posts",
+ *   fields: { author: relationship({ collection: "authors", required: true }) },
+ * });
+ * collectionConfigToVexSchema({ collection: posts, config });
+ * // → 'export const posts = defineTable({...})\n\t.index("by_author", ["author"])'
+ *
+ * @see {@link generateVexSchema} for the full-file generator that wraps this function
+ * @see {@link getIncomingRelationships} for the cross-collection helper
+ */
+export declare function collectionConfigToVexSchema(props: {
+    collection: CollectionConfig;
+    config: VexConfig;
+}): string;
+//# sourceMappingURL=validator.d.ts.map

package/dist/collections/validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.d.ts","sourceRoot":"","sources":["../../src/collections/validator.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAG3C;;;;;;;GAOG;AACH,MAAM,WAAW,oBAAoB;IACnC,oEAAoE;IACpE,QAAQ,EAAE,MAAM,CAAC;IACjB,kEAAkE;IAClE,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE;IAC9C,UAAU,EAAE,gBAAgB,CAAC;IAC7B,MAAM,EAAE,SAAS,CAAC;CACnB,GAAG,oBAAoB,EAAE,CA6BzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE;IACjD,UAAU,EAAE,gBAAgB,CAAC;IAC7B,MAAM,EAAE,SAAS,CAAC;CACnB,GAAG,MAAM,CAmDT"}

package/dist/config/config.d.ts

@@ -0,0 +1,43 @@
+import { VexConfig, VexConfigInput } from "./types";
+/**
+ * Resolves a raw Vex config input into a fully-populated `VexConfig`.
+ *
+ * Applies defaults for any omitted properties — an absent `collections`
+ * array is replaced with an empty array so downstream consumers can always
+ * iterate without null-checking.
+ *
+ * When an `auth` adapter is provided, its collections are merged with
+ * user-defined collections via {@link mergeAuthCollections}. Protected
+ * auth collections cannot be overridden, and locked fields are preserved.
+ *
+ * @param config - The raw Vex configuration supplied by the caller.
+ * @returns The resolved `VexConfig` with all defaults applied.
+ *
+ * @example
+ * ```ts
+ * // Basic config with user-defined collections only
+ * defineConfig({
+ *   collections: [
+ *     defineCollection({ slug: "posts", fields: { title: text() } }),
+ *   ],
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Config with Better Auth integration
+ * import { betterAuthAdapter } from "@vexcms/better-auth";
+ *
+ * defineConfig({
+ *   auth: betterAuthAdapter(authOptions),
+ *   collections: [posts, authors],
+ * });
+ * ```
+ *
+ * @see {@link VexConfigInput} for the user-facing input type
+ * @see {@link VexConfig} for the resolved return type
+ * @see {@link mergeAuthCollections} for auth collection merge logic
+ * @see {@link better-auth/src!betterAuthAdapter} for the Better Auth adapter
+ */
+export declare function defineConfig(config?: VexConfigInput): VexConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/config/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/config/config.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAgB,YAAY,CAAC,MAAM,CAAC,EAAE,cAAc,GAAG,SAAS,CAmD/D"}

package/dist/config/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./config";
+export * from "./types";
+export { sanitizeConfigForClient, stripNonSerializable } from "./sanitizeConfig";
+export type { ClientVexConfig } from "./sanitizeConfig";
+//# sourceMappingURL=index.d.ts.map

package/dist/config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,OAAO,EAAE,uBAAuB,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AACjF,YAAY,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/config/sanitizeConfig.d.ts

@@ -0,0 +1,82 @@
+import type { VexConfig } from "./types";
+/**
+ * A version of `VexConfig` safe to pass across RSC / JSON serialization
+ * boundaries. All non-serializable values (functions, React components, class
+ * instances, symbols) are replaced with `null`. The shape is otherwise
+ * identical to `VexConfig` — serializable fields retain their types.
+ *
+ * Produced by {@link sanitizeConfigForClient}.
+ *
+ * @see {@link VexConfig} for the full server-side config
+ * @see {@link sanitizeConfigForClient} for the sanitization function
+ */
+export type ClientVexConfig = Sanitized<Omit<VexConfig, "access">>;
+/**
+ * Recursively replaces all non-serializable values in a type with `null`.
+ *
+ * - Functions → `null`
+ * - Symbols → `null`
+ * - Class instances → `null`
+ * - Arrays → element type recursively sanitized
+ * - Plain objects → property types recursively sanitized
+ * - Primitives (string, number, boolean, null, undefined) → unchanged
+ */
+type Sanitized<T> = T extends (...args: any[]) => any ? null : T extends symbol ? null : T extends Array<infer U> ? Sanitized<U>[] : T extends object ? {
+    [K in keyof T]: Sanitized<T[K]>;
+} : T;
+/**
+ * Recursively strips all non-serializable values from an arbitrary value tree.
+ *
+ * Rules:
+ * - `null` / `undefined` → `null`
+ * - `function` → `null` (covers React components and callbacks)
+ * - `symbol` → `null`
+ * - Primitive (string, number, boolean) → returned as-is
+ * - Array → each element recursively processed
+ * - Plain object (`{}`) → each property recursively processed
+ * - Class instance (non-plain object) → `null`
+ *
+ * This function is intentionally exhaustive so that new non-serializable
+ * properties added anywhere in `VexConfig` are stripped automatically without
+ * requiring manual additions to `sanitizeConfigForClient`.
+ *
+ * @param value - Any value to sanitize.
+ * @returns A JSON-serializable version of `value`, with non-serializable
+ *   leaves replaced by `null`.
+ *
+ * @internal
+ */
+export declare function stripNonSerializable(value: unknown): unknown;
+/**
+ * Strips all non-serializable values from a `VexConfig` for safe passage
+ * across RSC / JSON serialization boundaries (e.g. server layout →
+ * client component).
+ *
+ * Uses {@link stripNonSerializable} to recursively walk the entire config
+ * tree, replacing functions, React components, class instances, and symbols
+ * with `null`. Adding a new non-serializable property anywhere in the config
+ * is handled automatically — no manual additions needed here.
+ *
+ * The `access` config is always omitted from the client version — it is
+ * never needed client-side and contains permission functions that cannot
+ * be serialized.
+ *
+ * @param config - The fully resolved server-side VexCMS config.
+ * @returns A deeply sanitized copy safe to pass to client components.
+ *
+ * @example
+ * ```ts
+ * // In a Next.js server component (e.g. AdminLayout):
+ * import vexConfig from "~/convex/vex.config";
+ * import { sanitizeConfigForClient } from "@vexcms/core";
+ *
+ * const clientConfig = sanitizeConfigForClient(vexConfig);
+ * return <AdminShell config={clientConfig} />;
+ * ```
+ *
+ * @see {@link ClientVexConfig} for the sanitized type
+ * @see {@link stripNonSerializable} for the recursive sanitizer
+ */
+export declare function sanitizeConfigForClient(config: VexConfig): ClientVexConfig;
+export {};
+//# sourceMappingURL=sanitizeConfig.d.ts.map

package/dist/config/sanitizeConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitizeConfig.d.ts","sourceRoot":"","sources":["../../src/config/sanitizeConfig.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC;;;;;;;;;;GAUG;AACH,MAAM,MAAM,eAAe,GAAG,SAAS,CAAC,IAAI,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC,CAAC;AAEnE;;;;;;;;;GASG;AAEH,KAAK,SAAS,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,GACjD,IAAI,GACJ,CAAC,SAAS,MAAM,GACd,IAAI,GACJ,CAAC,SAAS,KAAK,CAAC,MAAM,CAAC,CAAC,GACtB,SAAS,CAAC,CAAC,CAAC,EAAE,GACd,CAAC,SAAS,MAAM,GACd;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,GACnC,CAAC,CAAC;AAmBZ;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAwB5D;AAID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,SAAS,GAAG,eAAe,CAO1E"}

package/dist/config/types.d.ts

@@ -0,0 +1,316 @@
+import { CollectionConfig } from "../collections";
+import { VexAuthAdapter } from "../auth/types";
+import { MediaCollectionConfig, VexStorageAdapter } from "../media";
+import { StorageAdapterSlug } from "../types";
+import { GlobalConfig } from "../globals";
+import { VexAccessConfig } from "../access";
+/**
+ * User-facing configuration input for the VexCMS admin panel.
+ *
+ * All properties are optional — omitted properties fall back to the defaults below.
+ *
+ * **Defaults applied by `defineConfig()`:**
+ * ```ts
+ * {
+ *   sidebar: {
+ *     side: "left", // sidebar rendered on the left side of the viewport
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Move the sidebar to the right side
+ * defineConfig({
+ *   admin: { sidebar: { side: "right" } },
+ *   collections: [posts],
+ * })
+ * ```
+ *
+ * @see {@link AdminConfig} for the resolved type after defaults are applied
+ * @see {@link defineConfig} for the config function
+ */
+export interface AdminConfigInput {
+    /**
+     * Navigation sidebar configuration for the admin panel.
+     *
+     * Controls the sidebar that houses collection links and navigation items.
+     * All properties are optional; omitted values fall back to the defaults below.
+     *
+     * **Defaults applied by `defineConfig()`:**
+     * ```ts
+     * { side: "left" } // sidebar rendered on the left side of the viewport
+     * ```
+     */
+    sidebar?: {
+        /**
+         * Which side of the viewport the admin sidebar is anchored to.
+         *
+         * - `"left"` — sidebar sits on the left (default)
+         * - `"right"` — sidebar sits on the right
+         */
+        side?: "left" | "right";
+        /**
+         * How the sidebar in the admin panel collapses
+         *
+         * - `"offcanvas"` — A collapsible sidebar that slides in from the left or right.
+         * - `"icon"` — A sidebar that collapses to icons.
+         * - `"none"` — A non-collapsible sidebar.
+         */
+        collapsible?: "offcanvas" | "none" | "icon";
+    };
+}
+/**
+ * Resolved admin panel configuration after defaults are applied by `defineConfig()`.
+ *
+ * @see {@link AdminConfigInput} for the user-facing input type
+ * @see {@link defineConfig} for the config function
+ */
+export interface AdminConfig {
+    /** Navigation sidebar configuration — always present after defaults are applied. */
+    sidebar: {
+        /** Which side of the viewport the admin sidebar is anchored to. */
+        side: "left" | "right";
+        /**
+         * How the sidebar in the admin panel collapses
+         */
+        collapsible: "offcanvas" | "none" | "icon";
+    };
+}
+/**
+ * User-facing schema generation configuration for `defineConfig()`.
+ *
+ * Controls where generated files are written and whether automatic database
+ * migrations run when the schema changes. All properties are optional; omitted
+ * properties fall back to the defaults listed below.
+ *
+ * **Defaults applied by `defineConfig()`:**
+ * ```ts
+ * {
+ *   outputPath:      "/convex/vex.schema.ts", // vex.schema.ts output location
+ *   typesOutputPath: "/convex/vex.types.ts",  // vex.types.ts output location
+ *   autoMigrate:     false,                   // no auto-migration on schema change
+ *   autoRemove:      false,                   // removed tables stay in schema.ts
+ * }
+ *
+ * @see {@link SchemaConfig} for the resolved type after defaults are applied
+ */
+export interface SchemaConfigInput {
+    /**
+     * Path (relative to project root) where `vex.schema.ts` is written.
+     *
+     * Default: `"/convex/vex.schema.ts"`
+     */
+    outputPath?: string;
+}
+/**
+ * Resolved schema generation configuration after defaults are applied.
+ *
+ * @see {@link SchemaConfigInput} for the user-facing input type
+ */
+export interface SchemaConfig {
+    /** Path where `vex.schema.ts` is written. Always set after defaults are applied. */
+    outputPath: string;
+}
+/**
+ * User-facing schema generation configuration for `defineConfig()`.
+ *
+ * Controls where generated files are written and whether automatic database
+ * migrations run when the schema changes. All properties are optional; omitted
+ * properties fall back to the defaults listed below.
+ *
+ * **Defaults applied by `defineConfig()`:**
+ * ```ts
+ * {
+ *   outputPath:      "/convex/vex.schema.ts", // vex.schema.ts output location
+ *   typesOutputPath: "/convex/vex.types.ts",  // vex.types.ts output location
+ *   autoMigrate:     false,                   // no auto-migration on schema change
+ *   autoRemove:      false,                   // removed tables stay in schema.ts
+ * }
+ *
+ * @see {@link SchemaConfig} for the resolved type after defaults are applied
+ */
+export interface TypesConfigInput {
+    /**
+     * Path (relative to project root) where `vex.types.ts` is written.
+     *
+     * Default: `"/convex/vex.schema.ts"`
+     */
+    outputPath?: string;
+}
+/**
+ * Resolved schema generation configuration after defaults are applied.
+ *
+ * @see {@link SchemaConfigInput} for the user-facing input type
+ */
+export interface TypesConfig {
+    /** Path where `vex.types.ts` is written. Always set after defaults are applied. */
+    outputPath: string;
+}
+/**
+ * Client-side upload functions for each registered presigned-url adapter.
+ *
+ * Keys are `StorageAdapterSlug` — only adapters whose `type` is
+ * `"presigned-url"` and whose `name` appears in the config are valid.
+ * After `vex generate`, this is narrowed to the exact set of adapter
+ * names in the project.
+ *
+ * @example
+ * ```ts
+ * // apps/test/src/app/(vexcms)/admin/clientProviders.tsx
+ * import { StorageAdapterContextProvider } from "@vexcms/react";
+ * import { uploadFile } from "@vexcms/file-storage-convex/adapter";
+ *
+ * // Pass the map to StorageAdapterContextProvider — one entry per registered adapter.
+ * <StorageAdapterContextProvider adapterClients={{ convex: uploadFile }}>
+ *   {children}
+ * </StorageAdapterContextProvider>
+ * ```
+ */
+export type ClientUploadMap = Record<StorageAdapterSlug, (file: any, uploadUrl: string) => Promise<{
+    storageId: string;
+    url?: string;
+    [key: string]: unknown;
+}>>;
+/**
+ * User-facing configuration input passed to `defineConfig()`.
+ *
+ * All properties are optional — omitting `collections` produces an empty CMS
+ * with no custom content types registered.
+ *
+ * **Defaults applied by `defineConfig()`:**
+ * ```ts
+ * {
+ *   collections: [], // no collections registered — the CMS starts empty
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Register a collection
+ * defineConfig({
+ *   collections: [
+ *     defineCollection({ slug: "posts", fields: { title: text() } }),
+ *   ],
+ * });
+ *
+ * // Register collections and customise the admin panel
+ * defineConfig({
+ *   admin: { sidebar: { side: "right" } },
+ *   collections: [posts, authors],
+ * });
+ * ```
+ *
+ * @see {@link VexConfig} for the resolved type after defaults are applied
+ * @see {@link defineConfig} for the config function
+ */
+export interface VexConfigInput {
+    /**
+     * Admin panel configuration. All properties are optional — omitted values fall back to defaults.
+     *
+     * **Defaults applied by `defineConfig()`:**
+     * ```ts
+     * { sidebar: { side: "left" } }
+     * ```
+     *
+     * @see {@link AdminConfigInput} for all available options
+     */
+    admin?: AdminConfigInput;
+    access?: VexAccessConfig;
+    /** Content collections to register with the CMS. Defaults to `[]` if omitted. */
+    collections?: CollectionConfig[];
+    /** Singleton global documents. Each produced by `defineGlobal()`. Slugs must be unique. */
+    globals?: GlobalConfig[];
+    /**
+     * URL prefix for all admin panel routes.
+     *
+     * Default: `"/admin"`. Override when mounting the admin UI at a custom path
+     * (e.g. `"/cms"` or `"/dashboard/admin"`).
+     */
+    basePath?: string;
+    /**
+     * Schema generation configuration — controls output paths and auto-migration.
+     * All properties are optional; omitted values fall back to defaults.
+     *
+     * @see {@link SchemaConfigInput} for all available options
+     */
+    schema?: SchemaConfigInput;
+    types?: TypesConfigInput;
+    /**
+     * Auth adapter to register authentication collections (user, session,
+     * account, verification, etc.) alongside user-defined collections.
+     *
+     * Pass the return value of an auth adapter (e.g.
+     * {@link better-auth/src!betterAuthAdapter} from `@vexcms/better-auth`). Auth collections
+     * are merged with user collections by `defineConfig()` — protected auth
+     * collections cannot be overridden, and locked fields are preserved.
+     *
+     * @see {@link VexAuthAdapter} for the adapter interface
+     * @see {@link better-auth/src!betterAuthAdapter} for the Better Auth implementation
+     */
+    authAdapter?: VexAuthAdapter;
+    /**
+     * Storage configuration — adapters and client-side upload functions.
+     *
+     * When present, media collections are available in the admin panel and
+     * `upload()` fields can be used in regular collections. The `adapters`
+     * array holds the server-side adapter instances (stripped by
+     * `sanitizeConfigForClient`). The `clientUploads` map holds serializable
+     * `uploadFile` functions that the admin panel uses to upload files
+     * directly from the browser. Keys are `StorageAdapterSlug` — only
+     * presigned-url adapters registered in the config are valid.
+     *
+     * @see {@link VexStorageAdapter} for the adapter interface
+     * @see {@link StorageAdapterSlug} for the key type
+     * @see {@link file-storage-convex/src!convexFileStorage} from `@vexcms/file-storage-convex` for the first adapter
+     */
+    storage?: {
+        /** Storage adapters configured for the project. */
+        adapters: VexStorageAdapter[];
+    };
+}
+/**
+ * Resolved Vex CMS configuration after defaults are applied by `defineConfig()`.
+ *
+ * @see {@link VexConfigInput} for the user-facing input type
+ * @see {@link defineConfig} for the config function
+ */
+export interface VexConfig {
+    /** Resolved admin panel configuration — always fully populated after defaults are applied. */
+    admin: AdminConfig;
+    access?: VexAccessConfig;
+    /** All registered content collections — always an array after defaults are applied. */
+    collections: CollectionConfig[];
+    /** Resolved global configs. Always present; defaults to `[]`. */
+    globals: GlobalConfig[];
+    /** URL prefix for all admin panel routes — always set after defaults are applied. */
+    basePath: string;
+    /** Resolved schema generation configuration — always fully populated after defaults are applied. */
+    schema: SchemaConfig;
+    types: TypesConfig;
+    /**
+     * Auth adapter registered with this config. Auth collections are merged
+     * with user-defined collections — protected collections and locked fields
+     * are preserved during merge.
+     *
+     * @see {@link VexAuthAdapter} for the adapter interface
+     * @see {@link better-auth/src!betterAuthAdapter} for the Better Auth implementation
+     */
+    auth?: VexAuthAdapter;
+    /**
+     * Storage adapters registered with this config. Processed media collections
+     * from all adapters are available via `mediaCollections`.
+     */
+    storage?: {
+        /** Storage adapters configured for the project. */
+        adapters: VexStorageAdapter[];
+    };
+    /**
+     * Media collections — processed by storage adapters and stored separately
+     * from user-defined `collections`. These appear in the admin panel under a
+     * dedicated "Media" section. Each collection is tagged with
+     * `meta.storageAdapterName` indicating which adapter owns it.
+     */
+    mediaCollections: MediaCollectionConfig[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/config/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/config/types.ts"],"names":[],"mappings":"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"}

package/dist/fields/array/config.d.ts

@@ -0,0 +1,57 @@
+import { BaseFieldMeta } from "../types";
+import type { ArrayFieldInput, ArrayField, ArrayType } from "./types";
+/**
+ * Creates an array field with all defaults applied.
+ *
+ * Array fields store ordered lists of values — strings, numbers, booleans,
+ * or nested objects. Items are validated by a nested field definition
+ * (`items`) which supports any VexCMS field type including nested arrays.
+ *
+ * Accepts {@link ArrayFieldInput} (all optional) and returns {@link ArrayField}
+ * with all defaults applied.
+ *
+ * **Defaults applied:**
+ * - `label` — `""` (inferred from the field key by `defineCollection`)
+ * - `labels.singular` — `"Item"`
+ * - `labels.plural` — `"Items"`
+ * - `required` — `false`
+ * - `defaultValue` — `[]`
+ * - `admin.hidden` — `false`
+ * - `admin.readOnly` — `false`
+ * - `admin.position` — `"main"`
+ * - `admin.width` — `"full"`
+ * - `admin.cellAlignment` — `"left"`
+ *
+ * @param options - Array field configuration. All properties are optional.
+ * @returns Resolved array field definition with all defaults applied.
+ *
+ * @example
+ * ```ts
+ * import { array, text, defineCollection } from '@vexcms/core'
+ *
+ * posts: defineCollection({
+ *   fields: {
+ *     // Simple string tags array
+ *     tags: array({
+ *       items: text(),
+ *     }),
+ *
+ *     // Number array with a min length
+ *     scores: array({
+ *       items: number(),
+ *       min: { value: 1 },
+ *     }),
+ *
+ *     // Nested array — array of arrays of numbers
+ *     matrix: array({
+ *       items: array({ items: number() }),
+ *     }),
+ *   }
+ * })
+ * ```
+ *
+ * @see {@link ArrayFieldInput} for the full input type
+ * @see {@link ArrayField} for the resolved output type
+ */
+export declare function array<TArrayType extends ArrayType = string, TFieldMeta extends BaseFieldMeta = BaseFieldMeta>(options: ArrayFieldInput<TArrayType, TFieldMeta>): ArrayField<TArrayType, TFieldMeta>;
+//# sourceMappingURL=config.d.ts.map

package/dist/fields/array/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/fields/array/config.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,wBAAgB,KAAK,CACnB,UAAU,SAAS,SAAS,GAAG,MAAM,EACrC,UAAU,SAAS,aAAa,GAAG,aAAa,EAChD,OAAO,EAAE,eAAe,CAAC,UAAU,EAAE,UAAU,CAAC,GAAG,UAAU,CAAC,UAAU,EAAE,UAAU,CAAC,CA2CtF"}

package/dist/fields/array/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./config";
+export * from "./types";
+export * from "./validator";
+export * from "./inputSchema";
+//# sourceMappingURL=index.d.ts.map

package/dist/fields/array/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/fields/array/index.ts"],"names":[],"mappings":"AACA,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC"}

package/dist/fields/array/inputSchema.d.ts

@@ -0,0 +1,32 @@
+import { ZodType } from "zod";
+import { ArrayField, ArrayType } from "./types";
+/**
+ * Builds a Zod schema for validating an array field value in the admin form.
+ *
+ * Wraps the nested item schema in `z.array(…)`, applies `min`/`max` item count
+ * constraints when configured, then wraps in `.optional()` for non-required
+ * fields via `applyBaseInputSchemaMeta`. The item schema is built
+ * recursively by delegating to `adminFieldToInputSchema` for the nested field.
+ *
+ * @param props - Input props.
+ * @param props.field - The resolved array field definition
+ * @returns A Zod array schema with item count constraints, a baked-in `.default(field.defaultValue)`, and optionality applied
+ *
+ * @example
+ * ```ts
+ * const field = array({ items: text(), required: true })
+ * arrayFieldToInputSchema({ field })
+ * // → z.array(z.string()).superRefine(...).default([])
+ * ```
+ *
+ * @example
+ * ```ts
+ * const field = array({ items: number(), min: { value: 1 }, max: { value: 5 } })
+ * arrayFieldToInputSchema({ field })
+ * // → z.array(z.number()).min(1).max(5).default([])
+ * ```
+ */
+export declare function arrayFieldToInputSchema<TArrayType extends ArrayType = string, TFieldMeta extends {} = {}>(props: {
+    field: ArrayField<TArrayType, TFieldMeta>;
+}): ZodType;
+//# sourceMappingURL=inputSchema.d.ts.map

package/dist/fields/array/inputSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inputSchema.d.ts","sourceRoot":"","sources":["../../../src/fields/array/inputSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAK,OAAO,EAAE,MAAM,KAAK,CAAC;AACjC,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAIhD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,SAAS,SAAS,GAAG,MAAM,EACrC,UAAU,SAAS,EAAE,GAAG,EAAE,EAC1B,KAAK,EAAE;IAAE,KAAK,EAAE,UAAU,CAAC,UAAU,EAAE,UAAU,CAAC,CAAA;CAAE,GAAG,OAAO,CAyD/D"}