@vexcms/core 0.0.20 → 0.1.0-alpha.2

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

@@ -0,0 +1,45 @@
+import type { RelationshipFieldInput, RelationshipField } from "./types";
+import type { CollectionSlug } from "../../types/generated";
+import { ComponentHKT } from "../baseTypes";
+import { BaseFieldMeta } from "../types";
+/**
+ * Creates a relationship field with all defaults applied.
+ *
+ * Stores Convex `Id` references pointing to documents in another registered collection.
+ * The generated Convex schema **always** emits `v.array(v.id("collection"))` regardless
+ * of `hasMany` — `hasMany` is a UI-only hint that controls whether the admin picker allows
+ * one or multiple selections; it does not change the stored Convex type.
+ * A `.index("by_<fieldKey>", ["<fieldKey>"])` is auto-generated for every relationship
+ * field — no explicit `index` property needed.
+ *
+ * `TCollectionSlug` is inferred from `options.collection`. After running `vex generate`,
+ * passing an unregistered slug is a compile-time error.
+ *
+ * **Defaults applied:**
+ * - `label` — `""` (inferred from field key by `defineCollection`)
+ * - `required` — `false`
+ * - `hasMany` — `false`
+ * - `admin.hidden` — `false`
+ * - `admin.readOnly` — `false`
+ * - `admin.position` — `"main"`
+ * - `admin.width` — `"full"`
+ * - `admin.cellAlignment` — `"left"`
+ *
+ * @typeParam TCollectionSlug - Inferred from `options.collection`.
+ * @param options - Relationship field config. `collection` is required.
+ * @returns Resolved relationship field definition with all defaults applied.
+ *
+ * @example
+ * ```ts
+ * // Single reference — stores Id<"authors">
+ * author: relationship({ collection: { slug: "authors" } })
+ *
+ * // Multi-reference — stores Id<"tags">[]
+ * tags: relationship({ collection: { slug: "tags" }, hasMany: true, required: false })
+ * ```
+ *
+ * @see {@link RelationshipFieldInput} for the full input type
+ * @see {@link RelationshipField} for the resolved output type
+ */
+export declare function relationship<TFieldMeta extends BaseFieldMeta = BaseFieldMeta, TCollectionSlug extends CollectionSlug = CollectionSlug, TComponent extends ComponentHKT = ComponentHKT>(options: RelationshipFieldInput<TFieldMeta, TCollectionSlug, TComponent>): RelationshipField<TFieldMeta, TCollectionSlug, TComponent>;
+//# sourceMappingURL=config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/fields/relationship/config.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AACzE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,YAAY,CAC1B,UAAU,SAAS,aAAa,GAAG,aAAa,EAChD,eAAe,SAAS,cAAc,GAAG,cAAc,EACvD,UAAU,SAAS,YAAY,GAAG,YAAY,EAE9C,OAAO,EAAE,sBAAsB,CAAC,UAAU,EAAE,eAAe,EAAE,UAAU,CAAC,GACvE,iBAAiB,CAAC,UAAU,EAAE,eAAe,EAAE,UAAU,CAAC,CA0B5D"}

package/dist/fields/relationship/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/relationship/index.d.ts.map

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

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

@@ -0,0 +1,31 @@
+import { type ZodType } from "zod";
+import type { RelationshipField } from "./types";
+/**
+ * Builds a Zod schema for validating a relationship field value in the admin form.
+ *
+ * Convex document IDs are strings at the form boundary. Single references
+ * validate as `z.string()`. Multi-references (`hasMany: true`) validate as
+ * `z.array(z.string())` with a default of `[]`. Wraps in `.optional()` for
+ * non-required fields via `applyBaseInputSchemaMeta`.
+ *
+ * @param props - Input props.
+ * @param props.field - The resolved relationship field definition.
+ * @returns A Zod schema for the relationship value.
+ *
+ * @example
+ * ```ts
+ * // Single, optional (default)
+ * relationshipFieldToInputSchema({ field: relationship({ collection: { slug: "authors" } }) })
+ * // → z.array(z.string()).optional().default([])
+ *
+ * // Multi, required
+ * relationshipFieldToInputSchema({ field: relationship({ collection: { slug: "tags" }, hasMany: true, required: true }) })
+ * // → z.array(z.string()).default([])
+ * ```
+ *
+ * @internal
+ */
+export declare function relationshipFieldToInputSchema(props: {
+    field: RelationshipField;
+}): ZodType;
+//# sourceMappingURL=inputSchema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inputSchema.d.ts","sourceRoot":"","sources":["../../../src/fields/relationship/inputSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAK,KAAK,OAAO,EAAE,MAAM,KAAK,CAAC;AAEtC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAGjD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,8BAA8B,CAAC,KAAK,EAAE;IACpD,KAAK,EAAE,iBAAiB,CAAC;CAC1B,GAAG,OAAO,CAMV"}

package/dist/fields/relationship/types.d.ts

@@ -0,0 +1,126 @@
+import { ADMIN_FIELDS } from "../constants";
+import { ApplyComponent, BaseField, BaseFieldInput, ComponentHKT, FieldAdminConfig, FieldAdminConfigInput } from "../baseTypes";
+import { CollectionSlug } from "../../types/generated";
+import { RelationshipPreviewProps } from "../../collections";
+/**
+ * Admin configuration input specific to a relationship field instance.
+ *
+ * Extends {@link FieldAdminConfigInput} with a `components` slot that lets a
+ * single field override the preview renderer — taking precedence over the target
+ * collection's `admin.components.preview`.
+ *
+ * @typeParam TCollectionSlug - The target collection slug, inferred from the field's `collection` option.
+ * @see {@link RelationshipFieldAdminConfig} for the resolved type after defaults are applied
+ * @see {@link FieldAdminConfigInput} for the base admin properties
+ */
+export interface RelationshipFieldAdminInput<TCollectionSlug extends CollectionSlug = CollectionSlug, TComponent extends ComponentHKT = ComponentHKT> extends FieldAdminConfigInput {
+    /**
+     * Custom component overrides specific to this relationship field instance.
+     * These take precedence over the target collection's `admin.components`.
+     */
+    components?: {
+        /**
+         * Per-field override for rendering this relationship's docs. Wins over
+         * the target collection's `admin.components.preview`. `TCollectionSlug` is the
+         * *target* slug (`fieldDef.collection.slug`).
+         */
+        preview?: ApplyComponent<TComponent, RelationshipPreviewProps<TCollectionSlug>>;
+    };
+}
+/**
+ * Resolved admin configuration for a relationship field after defaults are applied.
+ *
+ * @typeParam TCollectionSlug - The target collection slug.
+ * @see {@link RelationshipFieldAdminInput} for the user-facing input type
+ */
+export interface RelationshipFieldAdminConfig<TCollectionSlug extends CollectionSlug = CollectionSlug, TComponent extends ComponentHKT = ComponentHKT> extends FieldAdminConfig {
+    /**
+     * Custom component overrides specific to this relationship field instance.
+     * These take precedence over the target collection's `admin.components`.
+     */
+    components: {
+        /**
+         * Per-field override for rendering this relationship's docs. Wins over
+         * the target collection's `admin.components.preview`. `TCollectionSlug` is the
+         * *target* slug (`fieldDef.collection.slug`).
+         */
+        preview?: ApplyComponent<TComponent, RelationshipPreviewProps<TCollectionSlug>>;
+    };
+}
+/**
+ * Configuration input for a `relationship()` field.
+ *
+ * Stores Convex `Id` references to documents in another registered collection.
+ * The Convex schema always uses `v.array(v.id("slug"))` regardless of `hasMany`.
+ * `hasMany` is a UI-only hint — `false` shows a single-selection picker,
+ * `true` shows a multi-selection picker. `TCollectionSlug` is inferred from the `collection`
+ * option — after running `vex generate`, invalid slugs are a compile-time error.
+ *
+ * **Defaults applied by `relationship()`:**
+ * ```ts
+ * {
+ *   type:     "relationship",
+ *   label:    "",    // inferred from the field key by defineCollection
+ *   required: false,
+ *   hasMany:  false, // single-select picker in the admin UI; schema is always v.array(v.id())
+ *   admin: {
+ *     hidden:        false,
+ *     readOnly:      false,
+ *     position:      "main",
+ *     width:         "full",
+ *     cellAlignment: "left",
+ *   }
+ * }
+ *
+ * @typeParam TCollectionSlug - The target collection slug. Inferred from `collection`.
+ *   Defaults to `CollectionSlug` (the full union after `vex generate`).
+ *
+ * @example
+ * ```ts
+ * // Single reference
+ * author: relationship({ collection: { slug: "authors" } })
+ *
+ * // Multi-reference
+ * tags: relationship({ collection: { slug: "tags" }, hasMany: true })
+ * ```
+ *
+ * @see {@link RelationshipField} for the resolved output type
+ * @see {@link relationship} for the config function
+ * @see {@link CollectionSlug} for the valid slug union
+ */
+export interface RelationshipFieldInput<TFieldMeta extends {} = {}, TCollectionSlug extends CollectionSlug = CollectionSlug, TComponent extends ComponentHKT = ComponentHKT> extends BaseFieldInput<TFieldMeta> {
+    /** Target collection reference. The slug must match a registered collection in `defineConfig`. */
+    collection: {
+        /** The slug of the collection this field links to. Must be a registered collection slug. */
+        slug: TCollectionSlug;
+    };
+    /**
+     * Whether this field stores multiple references.
+     * `false` stores a single `Id`, `true` stores `Id[]`.
+     * @defaultValue false
+     */
+    hasMany?: boolean;
+    admin?: BaseFieldInput["admin"] & RelationshipFieldAdminInput<TCollectionSlug, TComponent>;
+}
+/**
+ * Resolved configuration for a `relationship()` field, after all defaults are applied.
+ *
+ * `TCollection` is the string-literal type of the target collection's slug,
+ * inferred from `RelationshipFieldInput.collection`.
+ *
+ * @typeParam TCollection - The target collection slug (inferred from input).
+ * @see {@link RelationshipFieldInput} for the user-facing input type
+ * @see {@link relationship} for the config function
+ */
+export interface RelationshipField<TFieldMeta extends {} = {}, TCollectionSlug extends CollectionSlug = CollectionSlug, TComponent extends ComponentHKT = ComponentHKT> extends BaseField<TFieldMeta> {
+    readonly type: typeof ADMIN_FIELDS.relationship.type;
+    /** Target collection reference. */
+    collection: {
+        /** The slug of the collection this field links to. */
+        slug: TCollectionSlug;
+    };
+    /** Whether this field stores multiple document references. */
+    hasMany: boolean;
+    admin: BaseField<TFieldMeta>["admin"] & RelationshipFieldAdminConfig<TCollectionSlug, TComponent>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/fields/relationship/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/fields/relationship/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EACL,cAAc,EACd,SAAS,EACT,cAAc,EACd,YAAY,EACZ,gBAAgB,EAChB,qBAAqB,EACtB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAC;AAE7D;;;;;;;;;;GAUG;AACH,MAAM,WAAW,2BAA2B,CAC1C,eAAe,SAAS,cAAc,GAAG,cAAc,EACvD,UAAU,SAAS,YAAY,GAAG,YAAY,CAC9C,SAAQ,qBAAqB;IAC7B;;;OAGG;IACH,UAAU,CAAC,EAAE;QACX;;;;WAIG;QACH,OAAO,CAAC,EAAE,cAAc,CAAC,UAAU,EAAE,wBAAwB,CAAC,eAAe,CAAC,CAAC,CAAC;KACjF,CAAC;CACH;AAED;;;;;GAKG;AACH,MAAM,WAAW,4BAA4B,CAC3C,eAAe,SAAS,cAAc,GAAG,cAAc,EACvD,UAAU,SAAS,YAAY,GAAG,YAAY,CAC9C,SAAQ,gBAAgB;IACxB;;;OAGG;IACH,UAAU,EAAE;QACV;;;;WAIG;QACH,OAAO,CAAC,EAAE,cAAc,CAAC,UAAU,EAAE,wBAAwB,CAAC,eAAe,CAAC,CAAC,CAAC;KACjF,CAAC;CACH;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,MAAM,WAAW,sBAAsB,CACrC,UAAU,SAAS,EAAE,GAAG,EAAE,EAC1B,eAAe,SAAS,cAAc,GAAG,cAAc,EACvD,UAAU,SAAS,YAAY,GAAG,YAAY,CAC9C,SAAQ,cAAc,CAAC,UAAU,CAAC;IAClC,kGAAkG;IAClG,UAAU,EAAE;QACV,4FAA4F;QAC5F,IAAI,EAAE,eAAe,CAAC;KACvB,CAAC;IACF;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,cAAc,CAAC,OAAO,CAAC,GAC7B,2BAA2B,CAAC,eAAe,EAAE,UAAU,CAAC,CAAC;CAC5D;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,iBAAiB,CAChC,UAAU,SAAS,EAAE,GAAG,EAAE,EAC1B,eAAe,SAAS,cAAc,GAAG,cAAc,EACvD,UAAU,SAAS,YAAY,GAAG,YAAY,CAC9C,SAAQ,SAAS,CAAC,UAAU,CAAC;IAC7B,QAAQ,CAAC,IAAI,EAAE,OAAO,YAAY,CAAC,YAAY,CAAC,IAAI,CAAC;IACrD,mCAAmC;IACnC,UAAU,EAAE;QACV,sDAAsD;QACtD,IAAI,EAAE,eAAe,CAAC;KACvB,CAAC;IACF,8DAA8D;IAC9D,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,SAAS,CAAC,UAAU,CAAC,CAAC,OAAO,CAAC,GACnC,4BAA4B,CAAC,eAAe,EAAE,UAAU,CAAC,CAAC;CAC7D"}

package/dist/fields/relationship/validator.d.ts

@@ -0,0 +1,27 @@
+import type { RelationshipField } from "./types";
+/**
+ * Converts a relationship field definition to a Convex schema validator string.
+ *
+ * Emits `v.id("collection")` for single references and
+ * `v.array(v.id("collection"))` for multi-references. Wraps in `v.optional()`
+ * when `field.required` is `false`.
+ *
+ * @param props - Input props.
+ * @param props.field - The resolved relationship field definition.
+ * @returns Convex validator string.
+ *
+ * @example
+ * ```ts
+ * relationshipFieldToValidator({ field: relationship({ collection: { slug: "authors" }, required: true }) })
+ * // → 'v.array(v.id("authors"))'
+ *
+ * relationshipFieldToValidator({ field: relationship({ collection: { slug: "tags" }, hasMany: true }) })
+ * // → 'v.optional(v.array(v.id("tags")))'
+ * ```
+ *
+ * @internal
+ */
+export declare function relationshipFieldToValidator(props: {
+    field: RelationshipField;
+}): string;
+//# sourceMappingURL=validator.d.ts.map

package/dist/fields/relationship/validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.d.ts","sourceRoot":"","sources":["../../../src/fields/relationship/validator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,4BAA4B,CAAC,KAAK,EAAE;IAClD,KAAK,EAAE,iBAAiB,CAAC;CAC1B,GAAG,MAAM,CAIT"}

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

@@ -0,0 +1,59 @@
+import { BaseFieldMeta } from "../types";
+import type { SelectFieldInput, SelectField } from "./types";
+/**
+ * Creates a select field with all defaults applied.
+ *
+ * Select fields store an array of chosen option values — suitable for status
+ * labels, categories, tags, or any enumerable choice set. Set `hasMany: false`
+ * to restrict to a single selection.
+ *
+ * Accepts {@link SelectFieldInput} (all optional) and returns {@link SelectField} with all defaults applied.
+ *
+ * **Defaults applied:**
+ * - `label` — `""` (inferred from the field key by `defineCollection`)
+ * - `required` — `false`
+ * - `defaultValue` — `[]`
+ * - `options` — `[]`
+ * - `hasMany` — `false`
+ * - `admin.hidden` — `false`
+ * - `admin.readOnly` — `false`
+ * - `admin.position` — `"main"`
+ * - `admin.width` — `"full"`
+ * - `admin.cellAlignment` — `"left"`
+ *
+ * @param options - Select field configuration. All properties are optional.
+ * @returns Resolved select field definition with all defaults applied.
+ *
+ * @example
+ * ```ts
+ * import { select, defineCollection } from '@vexcms/core'
+ *
+ * posts: defineCollection({
+ *   fields: {
+ *     // Single-select status field
+ *     status: select({
+ *       required: true,
+ *       options: [
+ *         { label: "Draft", value: "draft" },
+ *         { label: "Published", value: "published" },
+ *       ],
+ *     }),
+ *
+ *     // Multi-select tag field
+ *     tags: select({
+ *       hasMany: true,
+ *       options: [
+ *         { label: "News", value: "news" },
+ *         { label: "Tutorial", value: "tutorial" },
+ *         { label: "Release", value: "release" },
+ *       ],
+ *     }),
+ *   }
+ * })
+ * ```
+ *
+ * @see {@link SelectFieldInput} for the full input type
+ * @see {@link SelectField} for the resolved output type
+ */
+export declare function select<TFieldMeta extends BaseFieldMeta = BaseFieldMeta>(options?: SelectFieldInput<TFieldMeta>): SelectField<TFieldMeta>;
+//# sourceMappingURL=config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/fields/select/config.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,wBAAgB,MAAM,CAAC,UAAU,SAAS,aAAa,GAAG,aAAa,EACrE,OAAO,CAAC,EAAE,gBAAgB,CAAC,UAAU,CAAC,GACrC,WAAW,CAAC,UAAU,CAAC,CAuBzB"}

package/dist/fields/select/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/select/index.d.ts.map

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

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

@@ -0,0 +1,28 @@
+import { ZodType } from "zod";
+import { SelectField } from "./types";
+/**
+ * Builds a Zod schema for validating a select field value in the admin form.
+ *
+ * Validates that submitted values are arrays containing only defined option values.
+ * When `hasMany` is false, limits the array to a maximum of one item.
+ * Wraps in `.optional()` for non-required fields via `applyBaseInputSchemaMeta`.
+ *
+ * @param props - Input props.
+ * @param props.field - The resolved select field definition
+ * @returns A Zod array schema constrained to valid option values, with a baked-in `.default(field.defaultValue)` and optionality applied
+ *
+ * @example
+ * ```ts
+ * const field = select({ required: true, options: [{ label: "Draft", value: "draft" }, { label: "Published", value: "published" }] })
+ * selectFieldToInputSchema({ field })
+ * // → z.array(z.enum(["draft", "published"])).default([])
+ *
+ * const singleField = select({ hasMany: false, options: [{ label: "Draft", value: "draft" }] })
+ * selectFieldToInputSchema({ field: singleField })
+ * // → z.array(z.enum(["draft"])).max(1, "Only one value may be selected.").default([])
+ * ```
+ */
+export declare function selectFieldToInputSchema(props: {
+    field: SelectField;
+}): ZodType;
+//# sourceMappingURL=inputSchema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inputSchema.d.ts","sourceRoot":"","sources":["../../../src/fields/select/inputSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAK,OAAO,EAAE,MAAM,KAAK,CAAC;AACjC,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAGtC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE;IAC9C,KAAK,EAAE,WAAW,CAAC;CACpB,GAAG,OAAO,CAoBV"}

package/dist/fields/select/types.d.ts

@@ -0,0 +1,89 @@
+import { ADMIN_FIELDS } from "../constants";
+import { BaseField, BaseFieldInput } from "../baseTypes";
+/**
+ * Configuration input for a `select()` field.
+ *
+ * Select fields store an array of chosen option values — status labels, categories,
+ * tags, or any enumerable set. All properties are optional; unset properties fall
+ * back to the defaults listed below.
+ *
+ * **Defaults applied by `select()`:**
+ * ```ts
+ * {
+ *   type:         "select",
+ *   label:        "",    // inferred from the field key by defineCollection
+ *   required:     false, // field is optional by default
+ *   defaultValue: [],    // empty selection
+ *   options:      [],    // no options configured
+ *   hasMany:      false, // single-select by default
+ *   admin: {
+ *     hidden:        false,   // visible in the admin form
+ *     readOnly:      false,   // editable by default
+ *     position:      "main",  // placed in the main content column, not the sidebar
+ *     width:         "full",  // spans the full form width, not half
+ *     cellAlignment: "left",  // aligned left in the data table column
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Single-select status
+ * status: select({
+ *   required: true,
+ *   options: [
+ *     { label: "Draft", value: "draft" },
+ *     { label: "Published", value: "published" },
+ *   ],
+ * })
+ *
+ * // Multi-select tags with badge colours
+ * tags: select({
+ *   hasMany: true,
+ *   options: [
+ *     { label: "News", value: "news", badgeColor: "#3b82f6" },
+ *     { label: "Tutorial", value: "tutorial", badgeColor: "#10b981" },
+ *   ],
+ * })
+ * ```
+ *
+ * @see {@link BaseFieldInput} for shared properties (`label`, `description`, `required`, `admin`, `index`)
+ */
+export interface SelectFieldInput<TFieldMeta extends {} = {}> extends BaseFieldInput<TFieldMeta> {
+    /**
+     * Pre-filled value shown in the admin form when creating a new field.
+     * Does not apply to database values
+     *
+     */
+    defaultValue?: string[];
+    options?: {
+        label: string;
+        value: string;
+        badgeColor?: string;
+    }[];
+    hasMany?: boolean;
+    optionInterfaceName?: string;
+}
+/**
+ * Resolved configuration for a `select()` field, after all defaults are applied.
+ *
+ * This is the type that framework adapters and field components receive —
+ * `fieldDef` in `InputComponentProps<SelectField>` and `CellComponentProps<SelectField>`
+ * is this type.
+ *
+ * @see {@link SelectFieldInput} for the user-facing input type
+ * @see {@link select} for the config function that produces this type
+ */
+export interface SelectField<TFieldMeta extends {} = {}> extends BaseField<TFieldMeta> {
+    readonly type: typeof ADMIN_FIELDS.select.type;
+    /** Pre-filled value shown in the admin form when creating a new field. */
+    defaultValue: string[];
+    options: {
+        label: string;
+        value: string;
+        badgeColor?: string;
+    }[];
+    hasMany: boolean;
+    optionInterfaceName?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/fields/select/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/fields/select/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,MAAM,WAAW,gBAAgB,CAC/B,UAAU,SAAS,EAAE,GAAG,EAAE,CAC1B,SAAQ,cAAc,CAAC,UAAU,CAAC;IAClC;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,OAAO,CAAC,EAAE;QACR,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,MAAM,CAAC;QACd,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,EAAE,CAAC;IACJ,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,WAAW,CAAC,UAAU,SAAS,EAAE,GAAG,EAAE,CAAE,SAAQ,SAAS,CAAC,UAAU,CAAC;IACpF,QAAQ,CAAC,IAAI,EAAE,OAAO,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC;IAC/C,0EAA0E;IAC1E,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,OAAO,EAAE;QACP,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,MAAM,CAAC;QACd,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,EAAE,CAAC;IACJ,OAAO,EAAE,OAAO,CAAC;IACjB,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B"}

package/dist/fields/select/validator.d.ts

@@ -0,0 +1,31 @@
+import type { SelectField } from "./types";
+/**
+ * Converts a select field definition to a Convex schema validator string.
+ *
+ * Generates a `v.array(v.union(...))` validator where each union member is a
+ * `v.literal("value")` for each configured option. Wraps in `v.optional()`
+ * when the field is not required.
+ *
+ * This function is used by the CLI during schema generation to build the Convex schema file.
+ *
+ * @param props - selectFieldToValidator() input props
+ * @param props.field - The resolved select field definition
+ * @returns Convex value type string, e.g. `v.array(v.union(v.literal("draft"), v.literal("published")))`
+ *
+ * @example
+ * ```ts
+ * const field1 = select({ required: true, options: [{ label: "Draft", value: "draft" }, { label: "Published", value: "published" }] })
+ * selectFieldToValidator({ field: field1 })
+ * // → 'v.array(v.union(v.literal("draft"), v.literal("published")))'
+ *
+ * const field2 = select({ required: false, options: [{ label: "Active", value: "active" }] })
+ * selectFieldToValidator({ field: field2 })
+ * // → 'v.optional(v.array(v.union(v.literal("active"))))'
+ * ```
+ *
+ * @internal - Used by schema generation, not typically called by users
+ */
+export declare function selectFieldToValidator(props: {
+    field: SelectField;
+}): string;
+//# sourceMappingURL=validator.d.ts.map

package/dist/fields/select/validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.d.ts","sourceRoot":"","sources":["../../../src/fields/select/validator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE;IAAE,KAAK,EAAE,WAAW,CAAA;CAAE,GAAG,MAAM,CAO5E"}

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

@@ -0,0 +1,48 @@
+import { BaseFieldMeta } from "../types";
+import type { TextFieldInput, TextField } from "./types";
+/**
+ * Creates a text field with all defaults applied.
+ *
+ * Text fields store short, single-line string values.
+ * Common uses: titles, names, slugs, URLs, email addresses.
+ *
+ * Accepts {@link TextFieldInput} (all optional) and returns {@link TextField} with all defaults applied.
+ *
+ * **Defaults applied:**
+ * - `label` — `""` (inferred from the field key by `defineCollection`)
+ * - `required` — `false`
+ * - `admin.hidden` — `false`
+ * - `admin.readOnly` — `false`
+ * - `admin.position` — `"main"`
+ * - `admin.width` — `"full"`
+ * - `admin.cellAlignment` — `"left"`
+ *
+ * @param options - Text field configuration. All properties are optional.
+ * @returns Resolved text field definition with all defaults applied.
+ *
+ * @example
+ * ```ts
+ * import { text, defineCollection } from '@vexcms/core'
+ *
+ * posts: defineCollection({
+ *   fields: {
+ *     // Minimal — label inferred from key ("Title")
+ *     title: text(),
+ *
+ *     // Required slug with length validation and a database index
+ *     slug: text({ required: true, min: { value: 3 }, max: { value: 100 }, index: "by_slug" }),
+ *
+ *     // Author name with a placeholder hint in the admin form
+ *     authorName: text({
+ *       required: true,
+ *       admin: { width: "half", placeholder: "e.g. Jane Smith" },
+ *     }),
+ *   }
+ * })
+ * ```
+ *
+ * @see {@link TextFieldInput} for the full input type
+ * @see {@link TextField} for the resolved output type
+ */
+export declare function text<TFieldMeta extends BaseFieldMeta = BaseFieldMeta>(options?: TextFieldInput<TFieldMeta>): TextField<TFieldMeta>;
+//# sourceMappingURL=config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/fields/text/config.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,KAAK,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,IAAI,CAAC,UAAU,SAAS,aAAa,GAAG,aAAa,EACnE,OAAO,CAAC,EAAE,cAAc,CAAC,UAAU,CAAC,GACnC,SAAS,CAAC,UAAU,CAAC,CA0BvB"}

package/dist/fields/text/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/text/index.d.ts.map

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

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

@@ -0,0 +1,24 @@
+import { ZodType } from "zod";
+import { TextField } from "./types";
+/**
+ * Builds a Zod schema for validating a text field value in the admin form.
+ *
+ * Applies `min`/`max` character-length constraints when configured, then
+ * wraps in `.optional()` for non-required fields via `applyBaseInputSchemaMeta`.
+ *
+ * @param props - Input props.
+ * @param props.field - The resolved text field definition
+ * @returns A Zod string schema with length constraints, a baked-in `.default(field.defaultValue)`, and optionality applied
+ *
+ * @example
+ * ```ts
+ * const field = text({ required: true, min: { value: 3 }, max: { value: 100 } })
+ * textFieldToInputSchema({ field })
+ * // → z.string().min(3).max(100).default("")
+ * // (a configured `min` supersedes the bare `.min(1)` required check)
+ * ```
+ */
+export declare function textFieldToInputSchema(props: {
+    field: TextField;
+}): ZodType;
+//# sourceMappingURL=inputSchema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inputSchema.d.ts","sourceRoot":"","sources":["../../../src/fields/text/inputSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAK,OAAO,EAAE,MAAM,KAAK,CAAC;AACjC,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAGpC;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE;IAAE,KAAK,EAAE,SAAS,CAAA;CAAE,GAAG,OAAO,CAkC3E"}