@stonecrop/schema 0.30.0 → 0.32.0

package/dist/src/field.js

@@ -1,378 +0,0 @@
-import { z } from 'zod';
-import { flattenFields } from './flatten';
-import { TableViewConfig } from './table';
-// Re-exported so callers already on this module keep one import; `flatten.ts` says why the
-// definition itself sits off to the side.
-export { flattenFields };
-/**
- * Field options - flexible bag for type-specific configuration.
- *
- * Usage:
- * - Select: array of choices (["Draft", "Submitted", "Cancelled"])
- * - Select with badges: \{ choices: [...], badges: \{ Open: "warning", ... \} \} or bare map
- * - Decimal: config object (\{ precision: 10, scale: 2 \})
- * - Code: config object (\{ language: "python" \})
- *
- * Deliberately *not* a bare string: a string once meant "link target", which made the value's
- * shape encode its meaning. That job belongs to `ValueField.doctype`, leaving this a plain
- * choices-or-config bag.
- *
- * @public
- */
-export const FieldOptions = z
-    .union([
-    z.array(z.string()), // Select choices: ["A", "B", "C"]
-    z.record(z.string(), z.unknown()), // Config: \{ precision: 10, scale: 2 \}
-])
-    .meta({
-    title: 'FieldOptions',
-    description: 'Field options - flexible bag for type-specific configuration',
-});
-/**
- * Validation configuration for form fields
- * @public
- */
-export const FieldValidation = z
-    .looseObject({
-    /** Error message to display when validation fails */
-    errorMessage: z.string(),
-})
-    .meta({
-    title: 'FieldValidation',
-    description: 'Validation configuration for form fields',
-});
-// ---------------------------------------------------------------------------
-// Zod runtime validation schemas
-// ---------------------------------------------------------------------------
-/**
- * Which of the three field shapes an entry has, read from the entry's own structure.
- *
- * The single definition of that question. It had three copies before this — the parser's
- * `injectKind`, {@link stripFieldKind}'s agreement check, and the docbuilder's own
- * `isValueField` in another package — each free to drift, and drift here re-types a field rather
- * than throwing: a value field read as a fieldset loses its column, a fieldset read as a value
- * field loses every child.
- *
- * Deliberately **shape-only**: a declared `kind` is ignored. Two callers depend on that. The
- * stripper compares this against the declaration to decide whether removing it is lossless, which
- * it cannot do if this honours it. The docbuilder reads raw JSON off disk and classifies entries to
- * decide which to render as editable rows — and `kind` is Stonecrop's own discriminant, not
- * something a doctype author writes, so a tool reading a file has no business consulting it.
- *
- * `injectKind` is the one place a declaration still wins, and only to leave an already-parsed
- * object untouched on its way back through.
- *
- * @param field - a field entry, authored or parsed
- * @returns the kind its shape implies
- * @public
- */
-export function inferFieldKind(field) {
-    if (typeof field !== 'object' || field === null || Array.isArray(field))
-        return 'field';
-    if ('schema' in field)
-        return 'fieldset';
-    if ('columns' in field)
-        return 'table';
-    return 'field';
-}
-/**
- * Infers the `kind` discriminant from the structural properties of a raw field
- * object, then injects it if absent. This allows authored JSON to omit `kind`
- * entirely — a `schema` key means fieldset, `columns` means table, anything else
- * is a value field.
- *
- * Rules (applied in order):
- *   has `schema`  → fieldset
- *   has `columns` → table
- *   otherwise     → field (value-holding scalar or link)
- *
- * Objects that already carry `kind` pass through unchanged (backward-compatible).
- *
- * Single-node only. Zod applies this at every level of the discriminated union (via the
- * `z.lazy` in the fieldset schema), so nested fieldset children are normalized during a
- * parse. Callers that bypass Zod — notably `Doctype.fromObject` — must use the exported
- * {@link normalizeFieldKind} instead, which replicates that recursion.
- */
-function injectKind(data) {
-    if (typeof data !== 'object' || data === null || Array.isArray(data))
-        return data;
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- safe: non-null, non-array object verified by guards above
-    const obj = data;
-    // An explicit `kind` is left exactly as it was found: this is the one place a declaration still
-    // beats the shape, and only so an already-parsed object survives a second pass unchanged.
-    // Returning `data` itself rather than rebuilding it also preserves identity and key order.
-    // Nothing outside this function shares that precedence — a reader classifying a file on disk
-    // wants `inferFieldKind`, because `kind` is ours and no author writes it.
-    if ('kind' in obj)
-        return data;
-    return { kind: inferFieldKind(obj), ...obj };
-}
-/**
- * Recursively injects the `kind` discriminant into a raw field object and, for fieldsets,
- * into each of its nested `schema` children — mirroring exactly what Zod's `preprocess`
- * does at every level of the discriminated union.
- *
- * Table `columns` are {@link ColumnSchema} entries, not `DoctypeField`s, so they are left
- * untouched — the Zod table schema validates them with a plain passthrough and never injects
- * `kind` there either.
- *
- * Needed because `Doctype.fromObject` constructs a Doctype without running Zod, yet the
- * registry's `resolveFields` gates link and fieldset handling on `field.kind`. Without this,
- * a JSON-authored link resolves to a flat scalar and a fieldset's children are dropped.
- *
- * @public
- */
-export function normalizeFieldKind(field) {
-    const injected = injectKind(field);
-    if (typeof injected !== 'object' || injected === null)
-        return injected;
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- injectKind returns a non-null object for object input; guarded above
-    const obj = injected;
-    if (obj.kind === 'fieldset' && Array.isArray(obj.schema)) {
-        return { ...obj, schema: obj.schema.map(normalizeFieldKind) };
-    }
-    return injected;
-}
-/**
- * Remove the `kind` discriminant from a field, recursing into a fieldset's children.
- *
- * The outbound half of the boundary {@link normalizeFieldKind} owns inbound. `kind` is a
- * discriminated-union tag the parser synthesizes, not something an author writes, so nothing that
- * *writes* a doctype should put it on disk — the generator and the docbuilder's save both call
- * this. Without it the two round-trip asymmetrically: every save adds a key the file never had.
- *
- * Strips only when `injectKind` would restore exactly what was removed. A fieldset carrying no
- * `schema` re-infers as a plain field, so its `kind` is kept rather than silently re-typing the
- * document; `DoctypeMeta` requires `schema` on a fieldset, so that shape is already invalid and
- * belongs to the load gate, not here.
- *
- * Table `columns` are {@link ColumnSchema} entries rather than `DoctypeField`s and never carry an
- * injected `kind`, so they are passed through untouched — the same asymmetry `injectKind` has.
- *
- * @param field - a field object, as held in memory after parsing
- * @returns the field without `kind`, safe to serialize
- * @public
- */
-export function stripFieldKind(field) {
-    if (typeof field !== 'object' || field === null || Array.isArray(field))
-        return field;
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- safe: non-null, non-array object verified by the guard above
-    const obj = field;
-    if (obj.kind !== undefined && obj.kind !== inferFieldKind(obj))
-        return field;
-    const { kind: _kind, ...rest } = obj;
-    if (Array.isArray(rest.schema)) {
-        return { ...rest, schema: rest.schema.map(stripFieldKind) };
-    }
-    return rest;
-}
-/**
- * The field properties a `source: 'introspected'` marker freezes — the ones the database owns.
- *
- * This is the single definition of the identity set. The docbuilder greys these inputs on an
- * introspected field, and the converter's merge refuses to rewrite them. Stating it twice is how
- * the two drift, so both read this constant.
- *
- * Everything absent from this list is author-owned, `component` most importantly: it chooses the
- * widget, which is an authoring decision the database has no opinion about.
- *
- * @public
- */
-export const INTROSPECTED_IDENTITY_PROPS = [
-    'fieldname',
-    'primaryKey',
-    'required',
-    'options',
-    'cardinality',
-    'doctype',
-];
-/**
- * Find the field a doctype marks as its primary key, or `undefined` when none is marked.
- *
- * This is the single definition of "which field identifies a record". Both sides depend on it:
- * the middleware builds the SQL identity predicate from it, and the client resolves a record's
- * route/store key from it. Call this; never re-derive the rule at the call site, or the two will
- * drift and the client will key records by a column the server never queried.
- *
- * Two deliberate rules, both matching the shape `primaryKey` actually has:
- * - Fieldset children are **included**, via {@link flattenFields}. A fieldset is layout, not
- *   scope: its children are fields of the doctype with columns of their own, which is why the
- *   adapter's SELECT already descends and why `getDisplayField` does too. Scanning top level only
- *   did not *refuse* a nested declaration — it ignored one, so an author marked identity and
- *   nothing honoured it and nothing said so.
- * - The **first** match in document order wins. Identity is single-valued by design — a doctype
- *   describes the API surface, and mapping a composite database key onto one identity there is the
- *   adapter's job — so a doctype declaring several is malformed rather than composite.
- *   `DoctypeMeta` rejects that at the load gate; this stays total for callers holding fields that
- *   never went through it.
- *
- * @param fields - the doctype's fields; fieldset children are descended into
- * @returns the primary-key field, or `undefined` for a PK-less doctype
- * @public
- */
-export function getPrimaryKeyField(fields) {
-    return flattenFields(fields).find((f) => f.kind === 'field' && Boolean(f.primaryKey));
-}
-/**
- * Resolve the field a doctype nominates as its display text, or `undefined` when the nomination
- * does not name a readable column.
- *
- * This is the single definition of "is this a usable `displayField`". Both sides depend on it:
- * `DoctypeMeta` refuses a bad nomination at the load gate, and the adapter builds a SELECT from
- * the field it returns. Call this; never re-derive the rule, or the gate and the query will
- * disagree about which nominations are legal — which they did, in both directions at once.
- *
- * Two things disqualify a nomination, and both are the doctype saying so itself:
- * - it names no field at all, fieldset children included
- * - it names a `computed` field, which is declared precisely to state it has no column, so a
- *   SELECT built from it would reference a column the database does not have
- *
- * @param fields - the doctype's top-level fields
- * @param displayField - the nominated fieldname
- * @returns the nominated field, or `undefined` when it is not a readable column
- * @public
- */
-export function getDisplayField(fields, displayField) {
-    if (!displayField)
-        return undefined;
-    return flattenFields(fields).find((f) => f.kind === 'field' && !f.computed && f.fieldname === displayField);
-}
-/**
- * The name of the field a record is identified by: the declared `primaryKey`, or `id` when the
- * doctype declares none.
- *
- * The `id` fallback is load-bearing, not defensive — a surrogate-key doctype carries an `id`
- * column and marks no primary key, so "nothing declared" means `id`, not "no identity".
- *
- * This exists because that one-line rule had been restated at four sites — the client's
- * `Doctype.recordIdField`, both nuxt hosts' `recordLookupField`, and the Postgres adapter — and
- * the fourth had omitted the fallback, so a doctype the client keyed by `id` was one the adapter
- * could not look up at all. Call this; a fifth restatement is how they diverge again.
- *
- * The returned name is not guaranteed to be a declared field: a doctype that declares no
- * `primaryKey` and no `id` yields `'id'` regardless. An adapter that must build a SQL predicate
- * from it has to confirm the field exists and say so when it does not, because selecting a column
- * the doctype never declared returns nothing rather than failing.
- *
- * @param fields - the doctype's top-level fields
- * @returns the identifying fieldname
- * @public
- */
-export function getRecordIdField(fields) {
-    return getPrimaryKeyField(fields)?.fieldname ?? 'id';
-}
-/**
- * Resolve a record's identity value using the doctype's declared primary key.
- *
- * Falls back to `record.id` when the doctype declares no `primaryKey`. That fallback is
- * load-bearing, not defensive: surrogate-key doctypes carry an `id` column and never mark a
- * primary key, and PostGraphile renames a single-column `id` PK to `rowId` — so the declared
- * field and `id` are both real sources, in that order.
- *
- * @param fields - the doctype's top-level fields
- * @param record - the record to read the identity from
- * @returns the identity as a string, or `undefined` when neither source yields a usable value
- * @public
- */
-export function getRecordIdentity(fields, record) {
-    const pkField = getPrimaryKeyField(fields);
-    const candidates = pkField ? [record[pkField.fieldname], record.id] : [record.id];
-    for (const value of candidates) {
-        // Numbers are valid keys (a serial PK); 0 is a legitimate id, so test the type, not truthiness.
-        if (typeof value === 'number')
-            return String(value);
-        if (typeof value === 'string' && value !== '')
-            return value;
-    }
-    return undefined;
-}
-function createDoctypeFieldSchemas() {
-    const ValueFieldSchema = z
-        .object({
-        kind: z.literal('field'),
-        fieldname: z.string().min(1),
-        component: z.string().min(1),
-        primaryKey: z.boolean().optional(),
-        computed: z.boolean().optional(),
-        language: z.string().optional(),
-        doctype: z.string().min(1).optional(),
-        label: z.string().optional(),
-        width: z.string().optional(),
-        height: z.string().optional(),
-        align: z.enum(['left', 'center', 'right', 'start', 'end']).optional(),
-        edit: z.boolean().optional(),
-        mask: z.string().optional(),
-        format: z.string().optional(),
-        mode: z.enum(['edit', 'read', 'display']).optional(),
-        options: FieldOptions.optional(),
-        required: z.boolean().optional(),
-        readOnly: z.boolean().optional(),
-        hidden: z.boolean().optional(),
-        default: z.unknown().optional(),
-        validation: FieldValidation.optional(),
-        cardinality: z.enum(['atMostOne', 'one', 'noneOrMany', 'atLeastOne']).optional(),
-        source: z.literal('introspected').optional(),
-    })
-        .meta({ title: 'ValueField' });
-    const TableFieldSchema = z
-        .object({
-        kind: z.literal('table'),
-        fieldname: z.string().min(1),
-        component: z.string().optional(),
-        label: z.string().optional(),
-        // Validates that each column has fieldname; allows all other ColumnSchema properties
-        columns: z.array(z.object({ fieldname: z.string().min(1) }).passthrough()),
-        config: TableViewConfig.optional(),
-        mode: z.enum(['edit', 'read', 'display']).optional(),
-    })
-        .meta({ title: 'TableField' });
-    // DoctypeFieldSchema must be declared before FieldsetFieldSchema so the z.lazy
-    // callback can close over it. The placeholder is overwritten below; the callback
-    // only runs at parse time, after the real discriminated union is assigned.
-    // See: https://zod.dev/api?id=discriminated-unions#discriminated-unions
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- required by Zod's recursive schema pattern; z.never() placeholder is overwritten before any parse call
-    let DoctypeFieldSchema = z.never();
-    // FieldsetFieldSchema stays as a plain ZodObject (not z.ZodType<T>) so that
-    // z.discriminatedUnion can inspect its 'kind' discriminant property.
-    const FieldsetFieldSchema = z
-        .object({
-        kind: z.literal('fieldset'),
-        fieldname: z.string().min(1),
-        component: z.string().optional(),
-        label: z.string().optional(),
-        collapsible: z.boolean().optional(),
-        mode: z.enum(['edit', 'read', 'display']).optional(),
-        schema: z.lazy(() => DoctypeFieldSchema.array()),
-    })
-        .meta({ title: 'FieldsetField' });
-    const rawUnion = z.discriminatedUnion('kind', [ValueFieldSchema, FieldsetFieldSchema, TableFieldSchema]);
-    // Overwrite the placeholder with the preprocessed schema. Because z.lazy captures
-    // DoctypeFieldSchema by closure reference, the lazy callback in FieldsetFieldSchema
-    // will resolve to this preprocessed version — so nested fieldsets also inject `kind`.
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- ZodPipe output is DoctypeField; same pattern as the z.never() placeholder above
-    DoctypeFieldSchema = z.preprocess(injectKind, rawUnion);
-    return { ValueFieldSchema, TableFieldSchema, FieldsetFieldSchema, DoctypeFieldSchema };
-}
-const schemas = createDoctypeFieldSchemas();
-/**
- * Zod runtime validation schema for ValueField.
- * @public
- */
-export const ValueFieldSchema = schemas.ValueFieldSchema;
-/**
- * Zod runtime validation schema for FieldsetField.
- * Recursive — FieldsetField.schema is validated against DoctypeFieldSchema.
- * @public
- */
-export const FieldsetFieldSchema = schemas.FieldsetFieldSchema;
-/**
- * Zod runtime validation schema for TableField.
- * @public
- */
-export const TableFieldSchema = schemas.TableFieldSchema;
-/**
- * Zod runtime validation schema for the DoctypeField discriminated union.
- * Validates all three field variants: `'field'`, `'fieldset'`, `'table'`.
- * @public
- */
-export const DoctypeFieldSchema = schemas.DoctypeFieldSchema;

package/dist/src/flatten.d.ts

@@ -1,29 +0,0 @@
-import type { DoctypeField, TableField, ValueField } from './field';
-/**
- * Recursively flatten Fieldset containers into a flat array of non-container fields.
- * Fieldset entries are replaced by their children; all other fields pass through.
- *
- * A fieldset is a layout grouping, not a scope: every field inside one is a field of the doctype,
- * with a column of its own and a name a link can bind to. Anything asking "what does this doctype
- * declare" must therefore descend, and the two ways to get that wrong point opposite ways — the
- * SELECT builder would omit real columns, while a validator would report a working declaration as
- * broken.
- *
- * Lives here rather than in the adapter because both sides need it: the middleware builds SQL from
- * it, and `DoctypeMeta`'s own validation asks the same question at the load gate. It sat in the
- * adapter while the validator hand-rolled a top-level-only scan, and that is exactly the second
- * failure this comment names — a `displayField` inside a fieldset was rejected at authoring time
- * and would have worked at runtime.
- *
- * A module of its own, importing nothing at runtime, because callers need the descent without
- * needing the rest of `field.ts` — which defines the Zod schemas, so a runtime edge to it is a
- * runtime edge to Zod. Zod reaching a Nitro SSR entry collides with the `process` Nitro imports
- * there and takes the server down with a `SyntaxError` per request, which no build reports.
- * `field.ts` still calls this and `index.ts` still exports it, so nothing outside moves.
- *
- * @param fields - the doctype's top-level fields
- * @returns every non-container field, fieldset children included
- * @public
- */
-export declare function flattenFields(fields: readonly DoctypeField[]): (ValueField | TableField)[];
-//# sourceMappingURL=flatten.d.ts.map

package/dist/src/flatten.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"flatten.d.ts","sourceRoot":"","sources":["../../src/flatten.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,GAAG,CAAC,UAAU,GAAG,UAAU,CAAC,EAAE,CAU1F"}

package/dist/src/flatten.js

@@ -1,38 +0,0 @@
-/**
- * Recursively flatten Fieldset containers into a flat array of non-container fields.
- * Fieldset entries are replaced by their children; all other fields pass through.
- *
- * A fieldset is a layout grouping, not a scope: every field inside one is a field of the doctype,
- * with a column of its own and a name a link can bind to. Anything asking "what does this doctype
- * declare" must therefore descend, and the two ways to get that wrong point opposite ways — the
- * SELECT builder would omit real columns, while a validator would report a working declaration as
- * broken.
- *
- * Lives here rather than in the adapter because both sides need it: the middleware builds SQL from
- * it, and `DoctypeMeta`'s own validation asks the same question at the load gate. It sat in the
- * adapter while the validator hand-rolled a top-level-only scan, and that is exactly the second
- * failure this comment names — a `displayField` inside a fieldset was rejected at authoring time
- * and would have worked at runtime.
- *
- * A module of its own, importing nothing at runtime, because callers need the descent without
- * needing the rest of `field.ts` — which defines the Zod schemas, so a runtime edge to it is a
- * runtime edge to Zod. Zod reaching a Nitro SSR entry collides with the `process` Nitro imports
- * there and takes the server down with a `SyntaxError` per request, which no build reports.
- * `field.ts` still calls this and `index.ts` still exports it, so nothing outside moves.
- *
- * @param fields - the doctype's top-level fields
- * @returns every non-container field, fieldset children included
- * @public
- */
-export function flattenFields(fields) {
-    const result = [];
-    for (const f of fields) {
-        if (f.kind === 'fieldset') {
-            result.push(...flattenFields(f.schema));
-        }
-        else {
-            result.push(f);
-        }
-    }
-    return result;
-}

package/dist/src/index.d.ts

@@ -1,16 +0,0 @@
-export type { InteractionMode } from './mode';
-export { TableViewConfig } from './table';
-export { CANONICAL_COMPONENTS, COMPONENT_CATEGORY, COMPONENT_LINK_EXPANSION, componentCategory, componentLinkExpansion, resolveLinkRenderMode, type ComponentCategory, type LinkExpansion, type LinkRenderMode, } from './component-meta';
-export type { DoctypeField, FieldOptions, FieldValidation, FieldsetField, TableField, ValueField } from './field';
-export { DoctypeFieldSchema, FieldsetFieldSchema, getDisplayField, getPrimaryKeyField, getRecordIdentity, getRecordIdField, INTROSPECTED_IDENTITY_PROPS, normalizeFieldKind, inferFieldKind, stripFieldKind, TableFieldSchema, ValueFieldSchema, } from './field';
-export { flattenFields } from './flatten';
-export { unwrapInlineLinks } from './record';
-export { ActionDefinition, TriggerDefinition, WorkflowLayout, WorkflowMeta, getDoctypeSlug, isActionAllowedInState, LINK_DISPLAY_SUFFIX, linkDisplayFieldname, } from './doctype';
-export type { Cardinality, CustomFetch, DataClient, DoctypeContext, DoctypeMeta, DoctypeRef, FetchStrategy, GetRecordOptions, GetRecordResult, GetRecordsOptions, GetRecordsResult, LazyFetch, LinkDeclaration, SerializedFunction, SyncFetch, } from './doctype';
-export { parseDoctype, parseField, validateDoctype, validateField, type ValidationError, type ValidationResult, } from './validation';
-export { aggregateDoctypeName, buildAggregateDoctype, buildScalarMap, classifyFieldType, convertGraphQLSchema, defaultIsEntityField, defaultIsEntityType, formatDoctypeDrift, GQL_SCALAR_MAP, INTERNAL_SCALARS, mergeIntrospectedDoctype, planGeneration, WELL_KNOWN_SCALARS, type AuthoredDoctype, type ConvertedGraphQLDoctype, type DoctypeDrift, type GraphQLConversionFieldMeta, type GenerationPlanEntry, type GenerationPlanOptions, type GraphQLConversionOptions, type IntrospectionSource, type MergeOptions, type MergeResult, } from './converter';
-export { toSlug, toPascalCase, pascalToSnake, snakeToCamel, camelToSnake, snakeToLabel, camelToLabel } from './naming';
-export type { ColumnSchema } from './column-schema';
-export type { BadgeDescriptor, BadgePresentation, BadgeSpec, BadgeSpecObject, BadgeVariant, SelectOptions, } from './badge';
-export { hasBadgeOptions, isBadgeDescriptor, isSelectChoiceMap, isSelectOptions, lookupBadge, selectChoices, } from './badge';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,YAAY,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAA;AAG7C,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAGzC,OAAO,EACN,oBAAoB,EACpB,kBAAkB,EAClB,wBAAwB,EACxB,iBAAiB,EACjB,sBAAsB,EACtB,qBAAqB,EACrB,KAAK,iBAAiB,EACtB,KAAK,aAAa,EAClB,KAAK,cAAc,GACnB,MAAM,kBAAkB,CAAA;AAGzB,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,eAAe,EAAE,aAAa,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AACjH,OAAO,EACN,kBAAkB,EAClB,mBAAmB,EACnB,eAAe,EACf,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,EAChB,2BAA2B,EAC3B,kBAAkB,EAClB,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,gBAAgB,GAChB,MAAM,SAAS,CAAA;AAGhB,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAGzC,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAK5C,OAAO,EACN,gBAAgB,EAChB,iBAAiB,EACjB,cAAc,EACd,YAAY,EACZ,cAAc,EACd,sBAAsB,EACtB,mBAAmB,EACnB,oBAAoB,GACpB,MAAM,WAAW,CAAA;AAClB,YAAY,EACX,WAAW,EACX,WAAW,EACX,UAAU,EACV,cAAc,EACd,WAAW,EACX,UAAU,EACV,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EACjB,gBAAgB,EAChB,SAAS,EACT,eAAe,EACf,kBAAkB,EAClB,SAAS,GACT,MAAM,WAAW,CAAA;AAGlB,OAAO,EACN,YAAY,EACZ,UAAU,EACV,eAAe,EACf,aAAa,EACb,KAAK,eAAe,EACpB,KAAK,gBAAgB,GACrB,MAAM,cAAc,CAAA;AAGrB,OAAO,EACN,oBAAoB,EACpB,qBAAqB,EACrB,cAAc,EACd,iBAAiB,EACjB,oBAAoB,EACpB,oBAAoB,EACpB,mBAAmB,EACnB,kBAAkB,EAClB,cAAc,EACd,gBAAgB,EAChB,wBAAwB,EACxB,cAAc,EACd,kBAAkB,EAClB,KAAK,eAAe,EACpB,KAAK,uBAAuB,EAC5B,KAAK,YAAY,EACjB,KAAK,0BAA0B,EAC/B,KAAK,mBAAmB,EACxB,KAAK,qBAAqB,EAC1B,KAAK,wBAAwB,EAC7B,KAAK,mBAAmB,EACxB,KAAK,YAAY,EACjB,KAAK,WAAW,GAChB,MAAM,aAAa,CAAA;AAGpB,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAGtH,YAAY,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAGnD,YAAY,EACX,eAAe,EACf,iBAAiB,EACjB,SAAS,EACT,eAAe,EACf,YAAY,EACZ,aAAa,GACb,MAAM,SAAS,CAAA;AAChB,OAAO,EACN,eAAe,EACf,iBAAiB,EACjB,iBAAiB,EACjB,eAAe,EACf,WAAW,EACX,aAAa,GACb,MAAM,SAAS,CAAA"}

package/dist/src/index.js

@@ -1,20 +0,0 @@
-// Table authoring types
-export { TableViewConfig } from './table';
-// Component → semantic category — the single source of "what kind of value does this component render"
-export { CANONICAL_COMPONENTS, COMPONENT_CATEGORY, COMPONENT_LINK_EXPANSION, componentCategory, componentLinkExpansion, resolveLinkRenderMode, } from './component-meta';
-export { DoctypeFieldSchema, FieldsetFieldSchema, getDisplayField, getPrimaryKeyField, getRecordIdentity, getRecordIdField, INTROSPECTED_IDENTITY_PROPS, normalizeFieldKind, inferFieldKind, stripFieldKind, TableFieldSchema, ValueFieldSchema, } from './field';
-// Field descent, kept a leaf so a caller needing only the descent does not take on zod
-export { flattenFields } from './flatten';
-// Record shaping — the single definition of what a record looks like on its way to the server
-export { unwrapInlineLinks } from './record';
-// Doctype schema
-// ActionDefinition and WorkflowMeta are exported as values (Zod schemas) so consumers can use
-// .safeParse(), .shape, etc. at runtime. TypeScript types are inferred from the same exports.
-export { ActionDefinition, TriggerDefinition, WorkflowLayout, WorkflowMeta, getDoctypeSlug, isActionAllowedInState, LINK_DISPLAY_SUFFIX, linkDisplayFieldname, } from './doctype';
-// Validation helpers
-export { parseDoctype, parseField, validateDoctype, validateField, } from './validation';
-// GraphQL to Doctype conversion
-export { aggregateDoctypeName, buildAggregateDoctype, buildScalarMap, classifyFieldType, convertGraphQLSchema, defaultIsEntityField, defaultIsEntityType, formatDoctypeDrift, GQL_SCALAR_MAP, INTERNAL_SCALARS, mergeIntrospectedDoctype, planGeneration, WELL_KNOWN_SCALARS, } from './converter';
-// Naming utilities
-export { toSlug, toPascalCase, pascalToSnake, snakeToCamel, camelToSnake, snakeToLabel, camelToLabel } from './naming';
-export { hasBadgeOptions, isBadgeDescriptor, isSelectChoiceMap, isSelectOptions, lookupBadge, selectChoices, } from './badge';

package/dist/src/mode.d.ts

@@ -1,15 +0,0 @@
-/**
- * Controls the level of user interaction for a field, container, or table.
- *
- * - `'edit'` — field is fully interactive; user can change the value
- * - `'read'` — field is non-interactive but displayed with form chrome (input outline, etc.)
- * - `'display'` — field is non-interactive and displayed as plain text; no form chrome
- *
- * Applied at authoring time via `mode` on any `DoctypeField` variant. Propagated through
- * `resolveSchema()` into the resolved output types. Nested `AForm` and `ATable` components
- * inherit `mode` from their parent unless overridden at the field level.
- *
- * @public
- */
-export type InteractionMode = 'edit' | 'read' | 'display';
-//# sourceMappingURL=mode.d.ts.map

package/dist/src/mode.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mode.d.ts","sourceRoot":"","sources":["../../src/mode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAAA"}

package/dist/src/naming.d.ts

@@ -1,80 +0,0 @@
-/**
- * Naming Convention Utilities
- * Converts between various naming conventions (snake_case, camelCase, PascalCase, kebab-case)
- * @packageDocumentation
- */
-/**
- * Converts snake_case to camelCase
- * @param snakeCase - Snake case string
- * @returns Camel case string
- * @public
- * @example
- * ```typescript
- * snakeToCamel('user_email') // 'userEmail'
- * snakeToCamel('created_at') // 'createdAt'
- * ```
- */
-export declare function snakeToCamel(snakeCase: string): string;
-/**
- * Converts camelCase to snake_case
- * @param camelCase - Camel case string
- * @returns Snake case string
- * @public
- * @example
- * ```typescript
- * camelToSnake('userEmail') // 'user_email'
- * camelToSnake('createdAt') // 'created_at'
- * ```
- */
-export declare function camelToSnake(camelCase: string): string;
-/**
- * Converts snake_case to Title Case label
- * @param snakeCase - Snake case string
- * @returns Title case label
- * @public
- * @example
- * ```typescript
- * snakeToLabel('user_email') // 'User Email'
- * snakeToLabel('first_name') // 'First Name'
- * ```
- */
-export declare function snakeToLabel(snakeCase: string): string;
-/**
- * Converts camelCase to Title Case label
- * @param camelCase - Camel case string
- * @returns Title case label
- * @public
- * @example
- * ```typescript
- * camelToLabel('userEmail') // 'User Email'
- * camelToLabel('firstName') // 'First Name'
- * ```
- */
-export declare function camelToLabel(camelCase: string): string;
-/**
- * Convert table name to PascalCase doctype name
- * @param tableName - SQL table name (snake_case)
- * @returns PascalCase name
- * @public
- */
-export declare function toPascalCase(tableName: string): string;
-/**
- * Convert to kebab-case slug
- * @param name - Name to convert
- * @returns kebab-case slug
- * @public
- */
-export declare function toSlug(name: string): string;
-/**
- * Convert PascalCase to snake_case (e.g., for deriving table names from type names)
- * @param pascal - PascalCase string
- * @returns snake_case string
- * @public
- * @example
- * ```typescript
- * pascalToSnake('SalesOrder') // 'sales_order'
- * pascalToSnake('SalesOrderItem') // 'sales_order_item'
- * ```
- */
-export declare function pascalToSnake(pascal: string): string;
-//# sourceMappingURL=naming.d.ts.map

package/dist/src/naming.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"naming.d.ts","sourceRoot":"","sources":["../../src/naming.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAKtD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAGtD;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAKtD;AAED;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAK3C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAKpD"}