@fougere/schema 0.10.0-alpha.0 → 0.12.0-alpha.0

package/src/projection/Cases.ts

@@ -95,66 +95,70 @@ export class Cases {
 function enumerate(entity: SchemaView, valid: Record<string, unknown>): ValidationCase[] {
   const fields = entity.getFields();
   const validator = InputValidator.of(fields);
+
+  return [
+    ...aboutTheInput(valid),
+    ...Object.entries(fields).flatMap(([name, field]) => aboutField(name, field as Field, valid, validator)),
+  ];
+}
+
+function aboutTheInput(valid: Record<string, unknown>): ValidationCase[] {
+  return [
+    { why: 'a valid input', input: valid, patch: false, expect: 'accept' },
+    {
+      why: 'a key outside the contract',
+      input: { ...valid, __unknown__: 'x' },
+      patch: false,
+      expect: { reject: '__unknown__' },
+    },
+    { why: 'not an object at all', input: 'a string', patch: false, expect: { reject: '.' } },
+  ];
+}
+
+function aboutField(
+  name: string,
+  field: Field,
+  valid: Record<string, unknown>,
+  validator: InputValidator,
+): ValidationCase[] {
+  const withField = (value: unknown) => ({ ...valid, [name]: value });
   const cases: ValidationCase[] = [];
-  const withField = (name: string, value: unknown) => ({ ...valid, [name]: value });
-
-  cases.push({ why: 'a valid input', input: valid, patch: false, expect: 'accept' });
-  cases.push({
-    why: 'a key outside the contract',
-    input: { ...valid, __unknown__: 'x' },
-    patch: false,
-    expect: { reject: '__unknown__' },
-  });
-  cases.push({
-    why: 'not an object at all',
-    input: 'a string',
-    patch: false,
-    expect: { reject: '.' },
-  });
-
-  for (const [name, field] of Object.entries(fields) as [string, Field][]) {
-    // A reference names a row that must exist; the caller supplied its id and we do not
-    // get to invent a second one, so the only case we can state about it is the bound one.
-    const isRef = Role.of(field).isReference;
-
-    if (validator.onAbsent(field) === null && name in valid) {
-      const input = { ...valid };
-      delete input[name];
-      cases.push({ why: `${name} absent`, input, patch: false, expect: { reject: name } });
-    }
 
-    if (Boundary.of(field).readOnly) {
-      cases.push({
-        why: `${name} supplied although read-only`,
-        input: withField(name, wrongTypeFor(field)),
-        patch: false,
-        expect: { reject: name },
-      });
-    }
+  if (validator.onAbsent(field) === null && name in valid) {
+    const input = { ...valid };
+    delete input[name];
+    cases.push({ why: `${name} absent`, input, patch: false, expect: { reject: name } });
+  }
 
-    if (Lifecycle.of(field).immutable && !Role.of(field).isPrimary) {
-      cases.push({
-        why: `${name} supplied on an update`,
-        input: { [name]: valid[name] ?? wrongTypeFor(field) },
-        patch: true,
-        expect: { reject: name },
-      });
-    }
+  if (Boundary.of(field).readOnly) {
+    cases.push({
+      why: `${name} supplied although read-only`,
+      input: withField(wrongTypeFor(field)),
+      patch: false,
+      expect: { reject: name },
+    });
+  }
 
-    if (name in valid && !isRef) {
-      cases.push({
-        why: `${name} of the wrong type`,
-        input: withField(name, wrongTypeFor(field)),
-        patch: false,
-        expect: { reject: name },
-      });
-      for (const { why, value } of outOfBoundsFor(field))
-        cases.push({
-          why: `${name} ${why}`,
-          input: withField(name, value),
-          patch: false,
-          expect: { reject: name },
-        });
+  if (Lifecycle.of(field).immutable && !Role.of(field).isPrimary) {
+    cases.push({
+      why: `${name} supplied on an update`,
+      input: { [name]: valid[name] ?? wrongTypeFor(field) },
+      patch: true,
+      expect: { reject: name },
+    });
+  }
+
+  // A reference names a row that must exist; the caller supplied its id and we do not
+  // get to invent a second one, so the only case we can state about it is the bound one.
+  if (name in valid && !Role.of(field).isReference) {
+    cases.push({
+      why: `${name} of the wrong type`,
+      input: withField(wrongTypeFor(field)),
+      patch: false,
+      expect: { reject: name },
+    });
+    for (const { why, value } of outOfBoundsFor(field)) {
+      cases.push({ why: `${name} ${why}`, input: withField(value), patch: false, expect: { reject: name } });
     }
   }
 
@@ -162,4 +166,4 @@ function enumerate(entity: SchemaView, valid: Record<string, unknown>): Validati
 }
 
 /** What a case names: the input itself, or the field the refusal lands on. */
-const rejected = (path: readonly string[]): string => (path.length === 0 ? '.' : path[0]!);
+const rejected = (path: readonly string[]): string => path[0] ?? '.';

package/src/projection/card/Bundle.ts

@@ -8,6 +8,7 @@ import type { SchemaDescriptor } from './SchemaDescriptor.js';
 import type { Diff } from './Diff.js';
 import type { SetDiff } from './SetDiff.js';
 import type { SetDiffOptions } from './SetDiffOptions.js';
+import { SchemaError } from '../../SchemaError.js';
 
 type SchemaSet = Record<string, SchemaView> | SchemaView[];
 
@@ -26,7 +27,7 @@ export class Bundle {
       const key = lowerFirst(entry.name);
       const previous = claimedBy.get(key);
       if (previous !== undefined) {
-        throw new Error(
+        throw new SchemaError(
           `Schemas '${previous}' and '${entry.name}' both claim bundle key '${key}'. `
           + 'Each schema in a bundle must have a distinct registration key.',
         );

package/src/projection/card/Card.ts

@@ -8,7 +8,7 @@ import { InputValidator } from '../../validator/InputValidator.js';
 import { Schema } from '../../Schema.js';
 import { type SchemaConstructor } from '../../SchemaConstructor.js';
 import type { SchemaView } from '../../SchemaView.js';
-import type { Values } from '../../Values.js';
+import type { Values } from '../../field/Values.js';
 import { admitPatterns, refuse } from './admission.js';
 import type { DerivedFrom } from './DerivedFrom.js';
 import type { FieldDescriptor } from './FieldDescriptor.js';
@@ -16,6 +16,7 @@ import type { FieldExtension } from './FieldExtension.js';
 import type { SchemaDescriptor } from './SchemaDescriptor.js';
 import { compare, type Diff } from './Diff.js';
 import { type DiffOptions } from './DiffOptions.js';
+import { SchemaError } from '../../SchemaError.js';
 
 type FieldsOf<T> = { [K in keyof T]-?: Field<T[K]> };
 
@@ -165,7 +166,11 @@ function originOf(schema: SchemaView): DerivedFrom | undefined {
  * `{ type: 'string', maxLength: 200 }` → the same shape `text({ max: 200 })` states
  */
 function reconstructShape(property: FieldDescriptor): Field['shape'] | undefined {
-  const types = Array.isArray(property.type) ? property.type : property.type ? [property.type] : [];
+  const types = Array.isArray(property.type)
+    ? property.type
+    : property.type
+      ? [property.type]
+      : [];
   if (!types.some((type) => type !== 'null')) return undefined;
 
   // `describeField` writes the shape whole, so it is read whole: a list of keywords here
@@ -188,7 +193,7 @@ function reconstructField(
 ): Field {
   const shape = reconstructShape(property);
   if (!shape) {
-    throw new Error(
+    throw new SchemaError(
       `Field '${key}': the card carries no \`type\` for it, so there is no shape to rebuild. ` +
         'A field always states one.',
     );
@@ -215,7 +220,10 @@ function reconstructField(
  * FR : écrit un groupe sur CHAQUE membre — un lecteur du fil ne voit qu'un champ.
  * `carryGroup(properties.listId, ['listId', 'docId'])` → the pair lands under its `role`
  */
-function carryGroup(property: FieldDescriptor | undefined, group: readonly string[]): void {
+function carryGroup(
+  property: FieldDescriptor | undefined,
+  group: readonly string[],
+): void {
   if (!property) return;
   const extension = (property['x-fougere'] ??= {}) as { role?: { unique?: string[][] } };
   const role = (extension.role ??= {});

package/src/projection/card/Diff.ts

@@ -27,65 +27,65 @@ export function compare(
   is: SchemaDescriptor,
   options: DiffOptions = {},
 ): Diff {
-  const changes: Change[] = [];
   const renamed = options.renamed ?? {};
   const before = was.properties ?? {};
   const after = is.properties ?? {};
-  const requiredBefore = new Set(was.required ?? []);
-  const requiredAfter = new Set(is.required ?? []);
+  const wasRequired = new Set(was.required ?? []);
+  const isRequired = new Set(is.required ?? []);
 
-  // Apply a declared rename first so subsequent differences use the new field name.
-  const nameAfter = (field: string): string => renamed[field] ?? field;
+  const kept: Change[] = [];
   const removed: string[] = [];
+  // A declared rename first, so every difference below is read under the new name.
   for (const [field, descriptor] of Object.entries(before)) {
-    const now = nameAfter(field);
+    const now = renamed[field] ?? field;
     const target = after[now];
     if (target === undefined) {
       removed.push(field);
       continue;
     }
+    kept.push(...movedIn(field, now, descriptor, target, wasRequired.has(field), isRequired.has(now)));
+  }
 
-    if (now !== field)
-      changes.push({ kind: 'renamed', from: field, to: now, field: target });
+  const claimed = new Set(Object.values(renamed));
+  const added = Object.keys(after).filter((field) => !(field in before) && !claimed.has(field));
 
-    const wasType = typesOf(descriptor);
-    const isType = typesOf(target);
-    if (!dequal(wasType, isType))
-      changes.push({ kind: 'retyped', field: now, from: wasType, to: isType });
-    else if (!dequal(boundsOf(descriptor), boundsOf(target))) {
-      changes.push({ kind: 'reshaped', field: now, from: descriptor, to: target });
-    }
+  return {
+    changes: [
+      ...kept,
+      ...removed.map((field): Change => ({
+        kind: 'removed', field, from: before[field]!, required: wasRequired.has(field),
+      })),
+      ...added.map((field): Change => ({
+        kind: 'added', field, to: after[field]!, required: isRequired.has(field),
+      })),
+    ],
+    ambiguous: candidates(removed, added, before, after),
+  };
+}
 
-    const wasRequired = requiredBefore.has(field);
-    const isRequired = requiredAfter.has(now);
-    if (wasRequired !== isRequired) {
-      changes.push({ kind: 'required', field: now, from: wasRequired, to: isRequired });
-    }
-    changes.push(...restated(now, descriptor['x-fougere'], target['x-fougere']));
-  }
+/** What one field that survived the two descriptions says about itself now. */
+function movedIn(
+  field: string,
+  now: string,
+  before: FieldDescriptor,
+  after: FieldDescriptor,
+  was: boolean,
+  is: boolean,
+): Change[] {
+  const changes: Change[] = [];
+  if (now !== field) changes.push({ kind: 'renamed', from: field, to: now, field: after });
 
-  const claimed = new Set(Object.values(renamed));
-  const added = Object.keys(after).filter(
-    (field) => !(field in before) && !claimed.has(field),
-  );
-  for (const field of removed) {
-    changes.push({
-      kind: 'removed',
-      field,
-      from: before[field],
-      required: requiredBefore.has(field),
-    });
-  }
-  for (const field of added) {
-    changes.push({
-      kind: 'added',
-      field,
-      to: after[field],
-      required: requiredAfter.has(field),
-    });
+  const wasType = typesOf(before);
+  const isType = typesOf(after);
+  if (!dequal(wasType, isType)) changes.push({ kind: 'retyped', field: now, from: wasType, to: isType });
+  else if (!dequal(boundsOf(before), boundsOf(after))) {
+    changes.push({ kind: 'reshaped', field: now, from: before, to: after });
   }
 
-  return { changes, ambiguous: candidates(removed, added, before, after) };
+  if (was !== is) changes.push({ kind: 'required', field: now, from: was, to: is });
+  changes.push(...restated(now, before['x-fougere'], after['x-fougere']));
+
+  return changes;
 }
 
 function restated(

package/src/projection/card/admission.ts

@@ -1,6 +1,7 @@
 import type { ValidationError } from '../../lib/ValidationError.js';
 import { Shapes } from '../../axis/shape/Shape.js';
 import { dotted } from '../../lib/ValidationResult.js';
+import { SchemaError } from '../../SchemaError.js';
 
 /**
  * Throws with what is wrong AND what to write: a card's author is in another process.
@@ -8,7 +9,7 @@ import { dotted } from '../../lib/ValidationResult.js';
  * `refuse('role.relation.kind is "maybe"', 'Expected one of one, many.')`
  */
 export function refuse(what: string, fix: string): never {
-  throw new Error(`This card cannot be read: ${what}.\n  ${fix}`);
+  throw new SchemaError(`This card cannot be read: ${what}.\n  ${fix}`);
 }
 
 /**

package/src/validator/AdapterFieldValidator.ts

@@ -1,6 +1,7 @@
 import { Validator } from '@cfworker/json-schema';
 import type { Shape } from '../axis/shape/Shape.js';
 import { isObject } from '../lib/utils.js';
+import { SchemaError } from '../SchemaError.js';
 
 /**
  * The format is DATA, not a TypeScript interface: an interface is erased before a JS
@@ -19,7 +20,7 @@ export class AdapterFieldValidator {
     if (entries === undefined) return;
 
     if (!isObject(entries)) {
-      throw new Error(
+      throw new SchemaError(
         `${path}: expected an object keyed by field name, got ${typeof entries}.`,
       );
     }
@@ -34,7 +35,7 @@ export class AdapterFieldValidator {
       const failure = units[units.length - 1] ?? verdict.errors[0];
       const nested = (failure?.instanceLocation ?? '#').slice(1).replaceAll('/', '.');
 
-      throw new Error(`${path}.${field}${nested}: ${failure?.error ?? 'does not match the format'}`);
+      throw new SchemaError(`${path}.${field}${nested}: ${failure?.error ?? 'does not match the format'}`);
     }
   }
 }

package/src/validator/FieldValueValidator.ts

@@ -5,8 +5,9 @@ import { Formats } from '../axis/shape/Formats.js';
 import { type Shape } from '../axis/shape/Shape.js';
 import { Shapes } from '../axis/shape/Shape.js';
 import type { Field } from '../field/Field.js';
-import type { Checked } from '../lib/Checked.js';
+import type { Verdict } from '../lib/Verdict.js';
 import type { OutputUnit } from '@cfworker/json-schema';
+import { SchemaError } from '../SchemaError.js';
 
 interface ShapePlan {
   validator: Validator;
@@ -24,24 +25,24 @@ export class FieldValueValidator {
     return new FieldValueValidator(field);
   }
 
-  validate(value: unknown): Checked {
+  validate(value: unknown): Verdict {
     const shape = this.field.shape;
     const type = Shapes.typeOf(shape);
     const base = Shapes.of(shape).base;
     if (value !== null) {
       if (base?.type === 'object' && !base.properties) return { value };
       if (type === 'date' && value instanceof Date) {
-        return Number.isNaN(value.getTime()) ? { error: 'Invalid date' } : { value };
+        return Number.isNaN(value.getTime()) ? { message: 'Invalid date' } : { value };
       }
       if ((type === 'number' || type === 'integer') && typeof value === 'number' && Number.isNaN(value)) {
-        return { error: 'Expected a number' };
+        return { message: 'Expected a number' };
       }
     }
     const plan = FieldValueValidator.planFor(shape);
     const result = plan.validator.validate(value);
     if (!result.valid) return refusalOf(result.errors);
     if (plan.custom && typeof value === 'string' && !plan.custom(value)) {
-      return { error: `String does not match format "${plan.formatName}".` };
+      return { message: `String does not match format "${plan.formatName}".` };
     }
     return { value };
   }
@@ -50,12 +51,12 @@ export class FieldValueValidator {
    * The value admitted, then handed back in the form the domain writes — an ISO string
    * arrives as a `Date`. `null` passes untouched, and a refusal stops before the codec.
    */
-  parse(value: unknown): Checked {
-    const checked = this.validate(value);
-    if ('error' in checked) return checked;
-    if (checked.value === null) return { value: null };
+  parse(value: unknown): Verdict {
+    const verdict = this.validate(value);
+    if ('message' in verdict) return verdict;
+    if (verdict.value === null) return { value: null };
 
-    return Boundary.of(this.field).decode(checked.value);
+    return Boundary.of(this.field).decode(verdict.value);
   }
 
   private static planFor(shape: Shape): ShapePlan {
@@ -76,7 +77,7 @@ export class FieldValueValidator {
   private static customFormatOf(name: string): FormatPredicate | undefined {
     const custom = Formats.find(name);
     if (!custom && !(name in engineFormats)) {
-      throw new Error(
+      throw new SchemaError(
         `Unknown format: '${name}'. Register it with Formats.register('${name}', …) — ` +
           `the engine validates ${Object.keys(engineFormats).length} formats natively and this is not one of them.`,
       );
@@ -90,15 +91,15 @@ export class FieldValueValidator {
  * parent's `Property "street" does not match schema.` — true, and never the reason. The
  * DEEPEST one is the reason, and it is the one that says where.
  */
-function refusalOf(errors: readonly OutputUnit[]): Checked {
+function refusalOf(errors: readonly OutputUnit[]): Verdict {
   const deepest = errors.reduce<OutputUnit | undefined>(
     (held, one) => (held && depthOf(held) >= depthOf(one) ? held : one),
     undefined,
   );
-  if (!deepest) return { error: 'Invalid value' };
+  if (!deepest) return { message: 'Invalid value' };
   const path = locationOf(deepest.instanceLocation);
 
-  return path.length > 0 ? { error: deepest.error, path } : { error: deepest.error };
+  return path.length > 0 ? { message: deepest.error, path } : { message: deepest.error };
 }
 
 const depthOf = (unit: OutputUnit): number => locationOf(unit.instanceLocation).length;

package/src/validator/InputValidator.ts

@@ -3,6 +3,7 @@ import { Lifecycle } from '../axis/lifecycle/Lifecycle.js';
 import { Role } from '../axis/role/Role.js';
 import type { Field } from '../field/Field.js';
 import type { Fields } from '../field/Fields.js';
+import type { Verdict } from '../lib/Verdict.js';
 import type { ValidationError } from '../lib/ValidationError.js';
 import type { ValidationResult } from '../lib/ValidationResult.js';
 import { FieldValueValidator } from './FieldValueValidator.js';
@@ -36,45 +37,42 @@ export class InputValidator {
     }
 
     const data = input as Record<string, unknown>;
-    const errors: ValidationError[] = [];
+    const errors: ValidationError[] = this.unknownIn(data);
     const row: Record<string, unknown> = {};
 
-    for (const key of Object.keys(data)) {
-      if (!Object.hasOwn(this.fields, key)) {
-        errors.push({ path: [key], message: InputRefusal.unknownField });
-      }
+    for (const [key, field] of Object.entries(this.fields)) {
+      const verdict = this.admit(field, data[key]);
+      if (verdict === undefined) continue;
+      if ('message' in verdict) errors.push({ path: [key, ...(verdict.path ?? [])], message: verdict.message });
+      else row[key] = verdict.value;
     }
 
-    for (const [key, field] of Object.entries(this.fields)) {
-      const path = [key];
-      const value = data[key];
+    if (errors.length > 0) return { success: false, errors };
 
-      if (value === undefined) {
-        if (this.options.patch) continue;
-        const absence = this.onAbsent(field);
-        if (absence === null) {
-          errors.push({ path, message: InputRefusal.required });
-          continue;
-        }
-        if (absence === 'empty-list') row[key] = [];
-        continue;
-      }
+    return { success: true, data: row };
+  }
 
-      if (Boundary.of(field).readOnly) {
-        errors.push({ path, message: InputRefusal.readOnly });
-        continue;
-      }
-      if (this.options.patch && Lifecycle.of(field).immutable) {
-        errors.push({ path, message: InputRefusal.immutable });
-        continue;
-      }
+  private unknownIn(data: Record<string, unknown>): ValidationError[] {
+    return Object.keys(data)
+      .filter((key) => !Object.hasOwn(this.fields, key))
+      .map((key) => ({ path: [key], message: InputRefusal.unknownField }));
+  }
 
-      const parsed = FieldValueValidator.of(field).parse(value);
-      if ('error' in parsed) errors.push({ path: [...path, ...parsed.path ?? []], message: parsed.error });
-      else row[key] = parsed.value;
-    }
+  private admit(field: Field, value: unknown): Verdict | undefined {
+    if (value === undefined) return this.whenAbsent(field);
 
-    if (errors.length > 0) return { success: false, errors };
-    return { success: true, data: row };
+    if (Boundary.of(field).readOnly) return { message: InputRefusal.readOnly };
+    if (this.options.patch && Lifecycle.of(field).immutable) return { message: InputRefusal.immutable };
+
+    return FieldValueValidator.of(field).parse(value);
+  }
+
+  private whenAbsent(field: Field): Verdict | undefined {
+    if (this.options.patch) return undefined;
+
+    const absence = this.onAbsent(field);
+    if (absence === null) return { message: InputRefusal.required };
+
+    return absence === 'empty-list' ? { value: [] } : undefined;
   }
 }

package/src/vocabulary/primitive/list.ts

@@ -1,4 +1,5 @@
 import { Field } from '../../field/Field.js';
+import { SchemaError } from '../../SchemaError.js';
 
 export interface ListOptions {
   min?: number;
@@ -12,7 +13,7 @@ export interface ListOptions {
  */
 export function list<T>(item: Field<T>, opts?: ListOptions): Field<T[]> {
   if (item.role?.relation)
-    throw new Error(
+    throw new SchemaError(
       'list() takes a value field (text(), number()…) — a relation has no value shape',
     );
   return new Field<T[]>({

package/src/vocabulary/primitive/ref.ts

@@ -1,9 +1,13 @@
 import { type EntityConstructor } from '../../axis/role/EntityConstructor.js';
-import { Relation } from '../../axis/role/Relation.js';
+import { Relation, type OnDelete } from '../../axis/role/Relation.js';
 import { Field } from '../../field/Field.js';
 
 export interface RefOptions {
-  cascade?: boolean;
+  /**
+   * What becomes of this row when the target's is deleted. `restrict` is the default because
+   * it is what a foreign key already does when nothing is stated.
+   */
+  onDelete?: OnDelete;
 }
 
 export function ref<E extends EntityConstructor>(
@@ -12,6 +16,6 @@ export function ref<E extends EntityConstructor>(
 ): Field<string> {
   return new Field<string>({
     shape: { type: 'string' },
-    role: { relation: Relation.one(target, opts?.cascade) },
+    role: { relation: Relation.one(target, opts?.onDelete) },
   });
 }

package/src/vocabulary/vocabulary.ts

@@ -1,6 +1,7 @@
 import { Field } from '../field/Field.js';
 import { EXTENSION_SLOTS } from '../axis/Axis.js';
 import { dequal } from 'dequal';
+import { SchemaError } from '../SchemaError.js';
 
 const MEMBER_SLOTS = [...EXTENSION_SLOTS, 'meta'] as const;
 
@@ -38,7 +39,7 @@ function merge(name: string, field: Field, given: Partial<Field>): Partial<Field
     for (const [member, value] of Object.entries(members)) {
       const previous = already?.[member];
       if (previous === undefined || dequal(previous, value)) continue;
-      throw new Error(
+      throw new SchemaError(
         `vocabulary: \`${name}\` states ${slot}.${member} = ${JSON.stringify(value)}, but the ` +
           `field already states ${JSON.stringify(previous)}. Apply one or the other, not both.`,
       );

package/dist/PartialValues.d.ts

@@ -1,4 +0,0 @@
-import type { Fields } from './field/Fields.js';
-import type { Values } from './Values.js';
-export type PartialValues<TFields extends Fields> = Partial<Values<TFields>>;
-//# sourceMappingURL=PartialValues.d.ts.map

package/dist/PartialValues.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PartialValues.d.ts","sourceRoot":"","sources":["../src/PartialValues.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C,MAAM,MAAM,aAAa,CAAC,OAAO,SAAS,MAAM,IAAI,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC"}

package/dist/PartialValues.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=PartialValues.js.map

package/dist/PartialValues.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"PartialValues.js","sourceRoot":"","sources":["../src/PartialValues.ts"],"names":[],"mappings":""}

package/dist/Values.d.ts

@@ -1,6 +0,0 @@
-import type { Field } from './field/Field.js';
-import type { Fields } from './field/Fields.js';
-export type Values<TFields extends Fields> = {
-    [K in keyof TFields]: TFields[K] extends Field<infer T> ? T : never;
-};
-//# sourceMappingURL=Values.d.ts.map

package/dist/Values.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Values.d.ts","sourceRoot":"","sources":["../src/Values.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,MAAM,MAAM,MAAM,CAAC,OAAO,SAAS,MAAM,IAAI;KAC1C,CAAC,IAAI,MAAM,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC,SAAS,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK;CACpE,CAAC"}

package/dist/Values.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Values.js","sourceRoot":"","sources":["../src/Values.ts"],"names":[],"mappings":""}

package/dist/axis/boundary/Boundaries.d.ts

@@ -1,17 +0,0 @@
-import type { Decoder } from './Decoder.js';
-import type { Encoder } from './Encoder.js';
-import type { BoundaryRules } from './BoundaryRules.js';
-import { Registry } from '../../lib/Registry.js';
-/**
- * `decoders` for a value coming in, `encoders` for one going out, `aliases` for the word
- * that names a pair. Three registries, so a codec is never half declared.
- * FR : `decoders` à l'entrée, `encoders` à la sortie, `aliases` pour le mot qui nomme la paire.
- * `Boundaries.aliases.register('isoDate', { in: { decode: 'isoDate' }, out: { encode: 'isoDate' } })`
- * → a field saying `boundary: 'isoDate'` decodes to a `Date` and leaves as a string
- */
-export declare const Boundaries: {
-    decoders: Registry<Decoder>;
-    encoders: Registry<Encoder>;
-    aliases: Registry<BoundaryRules>;
-};
-//# sourceMappingURL=Boundaries.d.ts.map

package/dist/axis/boundary/Boundaries.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Boundaries.d.ts","sourceRoot":"","sources":["../../../src/axis/boundary/Boundaries.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEjD;;;;;;GAMG;AACH,eAAO,MAAM,UAAU;IACrB,QAAQ;IAIR,QAAQ;IAIR,OAAO;CACR,CAAC"}