@strictly/define 0.0.1 → 0.0.2

package/.out/types/type_of_type.js

@@ -0,0 +1,70 @@
+import { map, UnreachableError, } from '@strictly/base';
+import { TypeDefType, } from 'types/definitions';
+export function typeOfType({ definition }) {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return {
+        definition: typeDefOfTypeDef(definition),
+    };
+}
+function typeDefOfTypeDef(t) {
+    switch (t.type) {
+        case TypeDefType.Literal:
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            return typeDefOfLiteralTypeDef(t);
+        case TypeDefType.List:
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            return typeDefOfListTypeDef(t);
+        case TypeDefType.Record:
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            return typeDefOfRecordTypeDef(t);
+        case TypeDefType.Object:
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            return typeDefOfObjectTypeDef(t);
+        case TypeDefType.Union:
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            return typeDefOfUnionTypeDef(t);
+        default:
+            throw new UnreachableError(t);
+    }
+}
+function typeDefOfLiteralTypeDef({ type, valuePrototype, }) {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return {
+        type,
+        valuePrototype,
+    };
+}
+function typeDefOfListTypeDef({ type, elements, }) {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return {
+        type,
+        elements: typeDefOfTypeDef(elements),
+    };
+}
+function typeDefOfRecordTypeDef({ type, keyPrototype, valueTypeDef, }) {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return {
+        type,
+        keyPrototype,
+        valueTypeDef: typeDefOfTypeDef(valueTypeDef),
+    };
+}
+function typeDefOfObjectTypeDef({ type, fields, }) {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return {
+        type,
+        fields: map(fields, function (_k, v) {
+            return typeDefOfTypeDef(v);
+        }),
+    };
+}
+function typeDefOfUnionTypeDef({ type, discriminator, unions, }) {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return {
+        type,
+        discriminator,
+        unions: map(unions, function (_k, v) {
+            return typeDefOfTypeDef(v);
+        }),
+    };
+}

package/.out/types/validating_definitions.d.ts

@@ -0,0 +1,49 @@
+import { type ObjectFieldKey, type RecordKeyType, type TypeDefType, type UnionKey } from './definitions';
+export type ValidatingType<T extends ValidatingTypeDef = ValidatingTypeDef> = {
+    readonly definition: T;
+};
+export type Rule<E = any, V = any> = (v: V) => E | null;
+export type ErrorOfValidatingTypeDef<T extends ValidatingTypeDef> = T extends ValidatingTypeDef<infer E> ? E : never;
+export type ValidatingTypeDef<E = any> = ValidatingLiteralTypeDef<E> | ValidatingListTypeDef<E> | ValidatingRecordTypeDef<E> | ValidatingObjectTypeDef<E> | ValidatingUnionTypeDef<E>;
+type AnyTypeDef = any;
+export type ValidatingLiteralTypeDef<E = any, V = any> = {
+    readonly type: TypeDefType.Literal;
+    readonly valuePrototype: [V];
+    readonly rule: Rule<E>;
+    readonly required: boolean;
+    readonly readonly: boolean;
+};
+export type ValidatingListTypeDef<E = any, Ele extends ValidatingTypeDef = AnyTypeDef> = {
+    readonly type: TypeDefType.List;
+    readonly elements: Ele;
+    readonly rule: Rule<E>;
+    readonly required: boolean;
+    readonly readonly: boolean;
+};
+export type ValidatingRecordTypeDef<E = any, K extends RecordKeyType = RecordKeyType, V extends ValidatingTypeDef | undefined = AnyTypeDef> = {
+    readonly type: TypeDefType.Record;
+    readonly keyPrototype: K;
+    readonly valueTypeDef: V;
+    readonly rule: Rule<E>;
+    readonly required: boolean;
+    readonly readonly: boolean;
+};
+export type ValidatingObjectTypeDefFields = {
+    [Key: ObjectFieldKey]: AnyTypeDef;
+};
+export type ValidatingObjectTypeDef<E = any, Fields extends ValidatingObjectTypeDefFields = ValidatingObjectTypeDefFields> = {
+    readonly type: TypeDefType.Object;
+    readonly fields: Fields;
+    readonly rule: Rule<E>;
+    readonly required: boolean;
+    readonly readonly: boolean;
+};
+export type ValidatingUnionTypeDef<E = any, D extends string | null = string | null, U extends Readonly<Record<UnionKey, AnyTypeDef>> = Readonly<Record<UnionKey, AnyTypeDef>>> = {
+    readonly discriminator: D;
+    readonly type: TypeDefType.Union;
+    readonly unions: U;
+    readonly rule: Rule<E>;
+    readonly required: boolean;
+    readonly readonly: boolean;
+};
+export {};

package/.out/types/validating_definitions.js

@@ -0,0 +1 @@
+export {};

package/.out/types/validating_type_def_with_error.d.ts

@@ -0,0 +1,55 @@
+import { type IsFieldReadonly } from '@strictly/base';
+import { type TypeDefType } from 'types/definitions';
+import { type Rule, type ValidatingListTypeDef, type ValidatingLiteralTypeDef, type ValidatingObjectTypeDef, type ValidatingRecordTypeDef, type ValidatingTypeDef, type ValidatingUnionTypeDef } from './validating_definitions';
+export type ValidatingTypeDefWithError<T extends ValidatingTypeDef, E> = T extends ValidatingLiteralTypeDef ? ValidatingLiteralTypeDefWithError<T, E> : T extends ValidatingListTypeDef ? ValidatingListTypeDefWithError<T, E> : T extends ValidatingRecordTypeDef ? ValidatingRecordTypeDefWithError<T, E> : T extends ValidatingObjectTypeDef ? ValidatingObjectTypeDefWithError<T, E> : T extends ValidatingUnionTypeDef ? ValidatingUnionTypeDefWithError<T, E> : never;
+type ValidatingLiteralTypeDefWithError<T extends ValidatingLiteralTypeDef, E2> = T extends ValidatingLiteralTypeDef<infer E1, infer V> ? {
+    readonly type: TypeDefType.Literal;
+    readonly valuePrototype: [V];
+    readonly rule: Rule<E1 | E2>;
+    readonly required: boolean;
+    readonly readonly: boolean;
+} : never;
+type ValidatingListTypeDefWithError<T extends ValidatingListTypeDef, E2> = T extends ValidatingListTypeDef<infer E1, infer E> ? IsFieldReadonly<T, 'elements'> extends true ? {
+    readonly type: TypeDefType.List;
+    readonly elements: E;
+    readonly rule: Rule<E1 | E2>;
+    readonly required: boolean;
+    readonly readonly: boolean;
+} : {
+    readonly type: TypeDefType.List;
+    elements: E;
+    readonly rule: Rule<E1 | E2>;
+    readonly required: boolean;
+    readonly readonly: boolean;
+} : never;
+type ValidatingRecordTypeDefWithError<T extends ValidatingRecordTypeDef, E2> = T extends ValidatingRecordTypeDef<infer E1, infer K, infer V> ? IsFieldReadonly<T, 'valueTypeDef'> extends true ? {
+    readonly type: TypeDefType.Record;
+    readonly keyPrototype: K;
+    readonly valueTypeDef: V;
+    readonly rule: Rule<E1 | E2>;
+    readonly required: boolean;
+    readonly readonly: boolean;
+} : {
+    readonly type: TypeDefType.Record;
+    readonly keyPrototype: K;
+    valueTypeDef: V;
+    readonly rule: Rule<E1 | E2>;
+    readonly required: boolean;
+    readonly readonly: boolean;
+} : never;
+type ValidatingObjectTypeDefWithError<T extends ValidatingObjectTypeDef, E2> = T extends ValidatingObjectTypeDef<infer E1, infer Fields> ? {
+    readonly type: TypeDefType.Object;
+    readonly fields: Fields;
+    readonly rule: Rule<E1 | E2>;
+    readonly required: boolean;
+    readonly readonly: boolean;
+} : never;
+type ValidatingUnionTypeDefWithError<T extends ValidatingUnionTypeDef, E2> = T extends ValidatingUnionTypeDef<infer E1, infer D, infer U> ? {
+    readonly type: TypeDefType.Union;
+    readonly discriminator: D;
+    readonly unions: U;
+    readonly rule: Rule<E1 | E2>;
+    readonly required: boolean;
+    readonly readonly: boolean;
+} : never;
+export {};

package/.out/types/validating_type_def_with_error.js

@@ -0,0 +1 @@
+export {};

package/.out/types/value_of_type.d.ts

@@ -0,0 +1,24 @@
+import { type IsFieldReadonly } from '@strictly/base';
+import { type ListTypeDef, type LiteralTypeDef, type ObjectTypeDef, type RecordTypeDef, type Type, type TypeDef, type UnionTypeDef } from './definitions';
+export type ValueOfType<T, Extra = {}> = T extends Type ? ValueOfTypeDef<T['definition'], Extra> : never;
+export type ValueOfTypeDef<F extends TypeDef, Extra = {}> = F extends LiteralTypeDef ? ValueOfLiteralTypeDef<F> : F extends ListTypeDef ? ValueOfListTypeDef<F, Extra> : F extends RecordTypeDef ? ValueOfRecordTypeDef<F, Extra> : F extends ObjectTypeDef ? ValueOfObjectTypeDef<F, Extra> : F extends UnionTypeDef ? ValueOfUnionTypeDef<F, Extra> : never;
+type ValueOfLiteralTypeDef<F extends LiteralTypeDef> = F['valuePrototype'][number];
+type ValueOfListTypeDef<F extends ListTypeDef, Extra> = IsFieldReadonly<F, 'elements'> extends true ? readonly ValueOfTypeDef<F['elements'], Extra>[] & Extra : ValueOfTypeDef<F['elements'], Extra>[] & Extra;
+type ValueOfRecordTypeDef<F extends RecordTypeDef, Extra> = undefined extends F['valueTypeDef'] ? IsFieldReadonly<F, 'valueTypeDef'> extends true ? {
+    readonly [k in F['keyPrototype']]?: ValueOfTypeDef<F['valueTypeDef'], Extra>;
+} : {
+    [k in F['keyPrototype']]?: ValueOfTypeDef<F['valueTypeDef'], Extra>;
+} : IsFieldReadonly<F, 'valueTypeDef'> extends true ? {
+    readonly [k in F['keyPrototype']]: ValueOfTypeDef<F['valueTypeDef'], Extra>;
+} : {
+    [k in F['keyPrototype']]: ValueOfTypeDef<F['valueTypeDef'], Extra>;
+};
+type ValueOfObjectTypeDef<F extends ObjectTypeDef, Extra> = F extends ObjectTypeDef<infer Fields> ? {
+    [K in keyof Fields]: ValueOfTypeDef<Fields[K], Extra>;
+} & Extra : never;
+type ValueOfUnionTypeDef<F extends UnionTypeDef, Extra> = F extends UnionTypeDef<infer D, infer U> ? D extends string ? {
+    [K in keyof U]: ValueOfTypeDef<U[K], Extra> & Readonly<Record<D, K>>;
+}[keyof U] : {
+    [K in keyof U]: ValueOfTypeDef<U[K], Extra>;
+}[keyof U] : never;
+export {};

package/.out/types/value_of_type.js

@@ -0,0 +1 @@
+export {};

package/.out/types/{value_to_type_paths_of.d.ts → value_to_type_paths_of_type.d.ts}

@@ -1,22 +1,22 @@
 import { type SimplifyDeep, type UnionToIntersection } from 'type-fest';
 import { type ListTypeDef, type LiteralTypeDef, type ObjectTypeDef, type RecordTypeDef, type TypeDef, type UnionTypeDef } from './definitions';
 import { type Depths, type StartingDepth } from './flattened';
-import { type JsonPathOf } from './json_path_of';
+import { type PathOf } from './path_of';
 import { type StrictType } from './strict_definitions';
-export type ValueToTypePathsOf<T extends StrictType, SegmentOverride extends string = '*', Path extends string = '$'> = SimplifyDeep<InternalFlattenedJsonPathsOf<T['definition'], SegmentOverride, Path, Path, StartingDepth>>;
-type InternalFlattenedJsonPathsOf<T extends TypeDef, SegmentOverride extends string, ValuePath extends string, TypePath extends string, Depth extends number> = {
+export type ValueToTypePathsOfType<T extends StrictType, SegmentOverride extends string = '*', Path extends string = '$'> = SimplifyDeep<InternalFlattenedTypePathsOf<T['definition'], SegmentOverride, Path, Path, StartingDepth>>;
+type InternalFlattenedTypePathsOf<T extends TypeDef, SegmentOverride extends string, ValuePath extends string, TypePath extends string, Depth extends number> = {
     readonly [K in ValuePath]: TypePath;
-} & InternalFlattenedJsonPathsOfChildren<T, SegmentOverride, ValuePath, TypePath, '', Depth>;
-type InternalFlattenedJsonPathsOfChildren<T extends TypeDef, SegmentOverride extends string, ValuePath extends string, TypePath extends string, Qualifier extends string, Depth extends number, NextDepth extends number = Depths[Depth]> = NextDepth extends -1 ? never : T extends LiteralTypeDef ? InternalFlattenedJsonPathsOfLiteralChildren : T extends ListTypeDef ? InternalFlattenedJsonPathsOfListChildren<T, SegmentOverride, ValuePath, TypePath, NextDepth> : T extends RecordTypeDef ? InternalFlattenedJsonPathsOfRecordChildren<T, SegmentOverride, ValuePath, TypePath, NextDepth> : T extends ObjectTypeDef ? InternalFlattenedJsonPathsOfObjectChildren<T, SegmentOverride, ValuePath, TypePath, Qualifier, NextDepth> : T extends UnionTypeDef ? InternalFlattenedJsonPathsOfUnionChildren<T, SegmentOverride, ValuePath, TypePath, Qualifier, NextDepth> : never;
-type InternalFlattenedJsonPathsOfLiteralChildren = {};
-type InternalFlattenedJsonPathsOfListChildren<T extends ListTypeDef, SegmentOverride extends string, ValuePath extends string, TypePath extends string, Depth extends number> = InternalFlattenedJsonPathsOf<T['elements'], SegmentOverride, JsonPathOf<ValuePath, number>, JsonPathOf<TypePath, number, SegmentOverride>, Depth>;
-type InternalFlattenedJsonPathsOfRecordChildren<T extends RecordTypeDef, SegmentOverride extends string, ValuePath extends string, TypePath extends string, Depth extends number> = InternalFlattenedJsonPathsOf<T['valueTypeDef'], SegmentOverride, JsonPathOf<ValuePath, T['keyPrototype']>, JsonPathOf<TypePath, T['keyPrototype'], SegmentOverride>, Depth>;
-type InternalFlattenedJsonPathsOfObjectChildren<T extends ObjectTypeDef, SegmentOverride extends string, ValuePath extends string, TypePath extends string, Qualifier extends string, Depth extends number> = T extends ObjectTypeDef<infer Fields> ? keyof Fields extends string ? UnionToIntersection<{
-    readonly [K in keyof Fields]-?: InternalFlattenedJsonPathsOf<Exclude<Fields[K], undefined>, SegmentOverride, JsonPathOf<ValuePath, `${Qualifier}${K}`>, JsonPathOf<TypePath, `${Qualifier}${K}`>, Depth>;
+} & InternalFlattenedTypePathsOfChildren<T, SegmentOverride, ValuePath, TypePath, '', Depth>;
+type InternalFlattenedTypePathsOfChildren<T extends TypeDef, SegmentOverride extends string, ValuePath extends string, TypePath extends string, Qualifier extends string, Depth extends number, NextDepth extends number = Depths[Depth]> = NextDepth extends -1 ? never : T extends LiteralTypeDef ? InternalFlattenedTypePathsOfLiteralChildren : T extends ListTypeDef ? InternalFlattenedTypePathsOfListChildren<T, SegmentOverride, ValuePath, TypePath, NextDepth> : T extends RecordTypeDef ? InternalFlattenedTypePathsOfRecordChildren<T, SegmentOverride, ValuePath, TypePath, NextDepth> : T extends ObjectTypeDef ? InternalFlattenedTypePathsOfObjectChildren<T, SegmentOverride, ValuePath, TypePath, Qualifier, NextDepth> : T extends UnionTypeDef ? InternalFlattenedTypePathsOfUnionChildren<T, SegmentOverride, ValuePath, TypePath, Qualifier, NextDepth> : never;
+type InternalFlattenedTypePathsOfLiteralChildren = {};
+type InternalFlattenedTypePathsOfListChildren<T extends ListTypeDef, SegmentOverride extends string, ValuePath extends string, TypePath extends string, Depth extends number> = InternalFlattenedTypePathsOf<T['elements'], SegmentOverride, PathOf<ValuePath, number>, PathOf<TypePath, number, SegmentOverride>, Depth>;
+type InternalFlattenedTypePathsOfRecordChildren<T extends RecordTypeDef, SegmentOverride extends string, ValuePath extends string, TypePath extends string, Depth extends number> = InternalFlattenedTypePathsOf<T['valueTypeDef'], SegmentOverride, PathOf<ValuePath, T['keyPrototype']>, PathOf<TypePath, T['keyPrototype'], SegmentOverride>, Depth>;
+type InternalFlattenedTypePathsOfObjectChildren<T extends ObjectTypeDef, SegmentOverride extends string, ValuePath extends string, TypePath extends string, Qualifier extends string, Depth extends number> = T extends ObjectTypeDef<infer Fields> ? keyof Fields extends string ? UnionToIntersection<{
+    readonly [K in keyof Fields]-?: InternalFlattenedTypePathsOf<Exclude<Fields[K], undefined>, SegmentOverride, PathOf<ValuePath, `${Qualifier}${K}`>, PathOf<TypePath, `${Qualifier}${K}`>, Depth>;
 }[keyof Fields]> : never : never;
-type InternalFlattenedJsonPathsOfUnionChildren<T extends UnionTypeDef, SegmentOverride extends string, ValuePath extends string, TypePath extends string, Qualifier extends string, Depth extends number> = T extends UnionTypeDef<infer D, infer Unions> ? keyof Unions extends string ? D extends null ? UnionToIntersection<{
-    readonly [K in keyof Unions]: InternalFlattenedJsonPathsOfChildren<Unions[K], SegmentOverride, ValuePath, TypePath, '', Depth>;
+type InternalFlattenedTypePathsOfUnionChildren<T extends UnionTypeDef, SegmentOverride extends string, ValuePath extends string, TypePath extends string, Qualifier extends string, Depth extends number> = T extends UnionTypeDef<infer D, infer Unions> ? keyof Unions extends string ? D extends null ? UnionToIntersection<{
+    readonly [K in keyof Unions]: InternalFlattenedTypePathsOfChildren<Unions[K], SegmentOverride, ValuePath, TypePath, '', Depth>;
 }[keyof Unions]> : UnionToIntersection<{
-    readonly [K in keyof Unions]: InternalFlattenedJsonPathsOfChildren<Unions[K], SegmentOverride, ValuePath, TypePath, `${Qualifier}${K}:`, Depth>;
+    readonly [K in keyof Unions]: InternalFlattenedTypePathsOfChildren<Unions[K], SegmentOverride, ValuePath, TypePath, `${Qualifier}${K}:`, Depth>;
 }[keyof Unions]> : never : never;
 export {};

package/.out/types/value_to_type_paths_of_type.js

@@ -0,0 +1 @@
+export {};

package/.out/types/value_types_of_discriminated_union.d.ts

@@ -1,9 +1,10 @@
 import { type UnionTypeDef } from './definitions';
-import { type ValueTypeOf } from './value_type_of';
+import { type ReadonlyTypeOfType } from './readonly_type_of_type';
+import { type ValueOfType } from './value_of_type';
 export type ValueTypesOfDiscriminatedUnion<U extends UnionTypeDef> = U extends UnionTypeDef<infer D, infer Unions> ? D extends string ? {
-    [K in keyof Unions]: ValueTypeOf<{
+    [K in keyof Unions]: ValueOfType<ReadonlyTypeOfType<{
         definition: Unions[K];
-    }> & {
-        [KD in D]: K;
+    }>> & {
+        readonly [KD in D]: K;
     };
 } : never : never;

package/.out/validation/errors_of_validators.d.ts

@@ -0,0 +1,4 @@
+import { type ErrorOfValidator, type Validator } from 'validation/validator';
+export type ErrorsOfValidators<Validators extends Record<string, Validator>> = {
+    readonly [K in keyof Validators]: ErrorOfValidator<Validators[K]>;
+};

package/.out/validation/errors_of_validators.js

@@ -0,0 +1 @@
+export {};

package/.out/validation/specs/errors_of_validators.tests.d.ts

@@ -0,0 +1 @@
+export {};

package/.out/validation/specs/errors_of_validators.tests.js

@@ -0,0 +1,9 @@
+describe('ErrorsOfValidators', function () {
+    describe('simple', function () {
+        let t;
+        it('equals expected type', function () {
+            expectTypeOf().toEqualTypeOf(t);
+        });
+    });
+});
+export {};

package/.out/validation/specs/validators_of_values.tests.d.ts

@@ -0,0 +1 @@
+export {};

package/.out/validation/specs/validators_of_values.tests.js

@@ -0,0 +1,21 @@
+describe('FlattenedValidatorsOfType', function () {
+    describe('literal', function () {
+        let t;
+        it('has the expected type', function () {
+            expectTypeOf().toEqualTypeOf(t);
+        });
+    });
+    describe('list', function () {
+        let t;
+        it('has the expected type', function () {
+            expectTypeOf().toEqualTypeOf(t);
+        });
+    });
+    describe('with defaults', function () {
+        let t;
+        it('has the expected type', function () {
+            expectTypeOf().toEqualTypeOf(t);
+        });
+    });
+});
+export {};

package/.out/validation/validator.d.ts

@@ -0,0 +1,21 @@
+import { type Simplify } from 'type-fest';
+export type FunctionalValidator<V = any, E = any, ValuePath extends string = any, Context = any> = (v: V, valuePath: ValuePath, context: Context) => E | null;
+export type AnnotatedValidator<V = any, E = any, ValuePath extends string = any, Context = any> = {
+    readonly validate: (v: V, valuePath: ValuePath, context: Context) => E | null;
+    readonly annotations: (valuePath: ValuePath, context: Context) => {
+        readonly required: boolean;
+        readonly readonly: boolean;
+    };
+};
+export type Validator<V = any, E = any, ValuePath extends string = any, Context = any> = FunctionalValidator<V, E, ValuePath, Context> | AnnotatedValidator<V, E, ValuePath, Context>;
+export type ErrorOfValidator<V extends Validator> = V extends Validator<infer _V, infer E> ? E : never;
+export type ValidationError<Type extends string, Data = {}> = Simplify<{
+    type: Type;
+} & Data>;
+export declare function isFunctionalValidator(v: Validator): v is FunctionalValidator;
+export declare function isAnnotatedValidator(v: Validator): v is AnnotatedValidator;
+export declare function validate<V = any, E = any, ValuePath extends string = any, Context = any>(validator: Validator<V, E, ValuePath, Context>, v: V, valuePath: ValuePath, context: Context): E | null;
+export declare function annotations<V = any, E = any, ValuePath extends string = any, Context = any>(validator: Validator<V, E, ValuePath, Context>, valuePath: ValuePath, context: Context): {
+    readonly required: boolean;
+    readonly readonly: boolean;
+};

package/.out/validation/validator.js

@@ -0,0 +1,26 @@
+export function isFunctionalValidator(v) {
+    return typeof v === 'function';
+}
+export function isAnnotatedValidator(v) {
+    return typeof v !== 'function';
+}
+export function validate(validator, v, valuePath, context) {
+    if (isAnnotatedValidator(validator)) {
+        return validator.validate(v, valuePath, context);
+    }
+    else {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        return validator(v, valuePath, context);
+    }
+}
+export function annotations(validator, valuePath, context) {
+    if (isAnnotatedValidator(validator)) {
+        return validator.annotations(valuePath, context);
+    }
+    else {
+        return {
+            required: false,
+            readonly: false,
+        };
+    }
+}

package/.out/validation/validators/defined_validator.d.ts

@@ -0,0 +1,10 @@
+import { type AnnotatedValidator } from 'validation/validator';
+export declare class DefinedValidator<V, E, ValuePath extends string, Context> implements AnnotatedValidator<V | null | undefined, E, ValuePath, Context> {
+    private readonly error;
+    constructor(error: E);
+    validate(v: V | null | undefined): E | null;
+    annotations(): {
+        required: boolean;
+        readonly: boolean;
+    };
+}

package/.out/validation/validators/defined_validator.js

@@ -0,0 +1,18 @@
+export class DefinedValidator {
+    error;
+    constructor(error) {
+        this.error = error;
+    }
+    validate(v) {
+        if (v == null) {
+            return this.error;
+        }
+        return null;
+    }
+    annotations() {
+        return {
+            required: true,
+            readonly: false,
+        };
+    }
+}

package/.out/validation/validators/minimum_string_length_validator.d.ts

@@ -0,0 +1,16 @@
+import { type AnnotatedValidator } from 'validation/validator';
+export declare const MinimumStringLengthValidationErrorType = "minimum_string_length";
+export type MinimumStringLengthValidationError = {
+    type: typeof MinimumStringLengthValidationErrorType;
+    receivedLength: number;
+    minimumLength: number;
+};
+export declare class MinimumStringLengthValidator<ValuePath extends string, Context> implements AnnotatedValidator<string, MinimumStringLengthValidationError, ValuePath, Context> {
+    private readonly minimumLength;
+    constructor(minimumLength: number);
+    validate(value: string): MinimumStringLengthValidationError | null;
+    annotations(): {
+        required: boolean;
+        readonly: boolean;
+    };
+}

package/.out/validation/validators/minimum_string_length_validator.js

@@ -0,0 +1,23 @@
+export const MinimumStringLengthValidationErrorType = 'minimum_string_length';
+export class MinimumStringLengthValidator {
+    minimumLength;
+    constructor(minimumLength) {
+        this.minimumLength = minimumLength;
+    }
+    validate(value) {
+        if (value.length < this.minimumLength) {
+            return {
+                type: MinimumStringLengthValidationErrorType,
+                minimumLength: this.minimumLength,
+                receivedLength: value.length,
+            };
+        }
+        return null;
+    }
+    annotations() {
+        return {
+            required: true,
+            readonly: false,
+        };
+    }
+}

package/.out/validation/validators_of_values.d.ts

@@ -0,0 +1,4 @@
+import { type Validator } from 'validation/validator';
+export type ValidatorsOfValues<FlattenedValues extends Readonly<Record<string, any>>, TypePathsToValuePaths extends Readonly<Record<keyof FlattenedValues, string>> = Readonly<Record<keyof FlattenedValues, any>>, Context = any> = {
+    readonly [K in keyof FlattenedValues]: Validator<FlattenedValues[K], any, TypePathsToValuePaths[K], Context>;
+};

package/.out/validation/validators_of_values.js

@@ -0,0 +1 @@
+export {};

package/.turbo/turbo-build.log

@@ -3,16 +3,16 @@ $ tsup
 CLI Building entry: index.ts
 CLI Using tsconfig: tsconfig.build.json
 CLI tsup v8.3.5
-CLI Using tsup config: /home/runner/work/de/de/packages/define/tsup.config.ts
+CLI Using tsup config: /home/runner/work/strictly/strictly/packages/define/tsup.config.ts
 CLI Target: esnext
 CJS Build start
 ESM Build start
-CJS dist/index.cjs 20.29 KB
-CJS ⚡️ Build success in 60ms
-ESM dist/index.js 18.58 KB
-ESM ⚡️ Build success in 59ms
+CJS dist/index.cjs 26.97 KB
+CJS ⚡️ Build success in 50ms
+ESM dist/index.js 24.77 KB
+ESM ⚡️ Build success in 52ms
 DTS Build start
-DTS ⚡️ Build success in 4995ms
-DTS dist/index.d.cts 22.22 KB
-DTS dist/index.d.ts  22.22 KB
-Done in 5.97s.
+DTS ⚡️ Build success in 5601ms
+DTS dist/index.d.cts 38.05 KB
+DTS dist/index.d.ts  38.05 KB
+Done in 6.43s.

package/.turbo/turbo-check-types.log

@@ -1,3 +1,3 @@
 yarn run v1.22.22
 $ tsc
-Done in 4.06s.
+Done in 5.18s.

package/.turbo/turbo-release$colon$exports.log

@@ -1,3 +1,3 @@
 yarn run v1.22.22
 $ json -f package.json -f package.exports.json --merge > package.release.json
-Done in 0.08s.
+Done in 0.11s.

package/README.md

@@ -1,12 +1,26 @@
-# Define
-
 Type definitions for specifying and modifying types
 
+# Define Your Types
+
+One of the goals of @strictly/form is to provide a type-safe mapping between your display types and your domain types. In order to achieve this we need to be able to specify those types.
+
 ## Defining Types
 
 ## Type Builder
 
+# Transforming Types
+
 ## Modifying Types
 
 ## Modifying Values
 
+# FAQ
+
+## Why not use Zod (or equivalent)?
+
+While [Zod](https://zod.dev/) is a great tool, with many, many features and great supporting libraries, it does not produce 100% introspectable type definitions. Our definitions need to be quite minimal, while Zod's are quite fully featured. The reasons for this are
+1. The Typescript compiler is actually fairly limited in how much it processing it will do on a [Mapped Type](https://www.typescriptlang.org/docs/handbook/2/mapped-types.html) before it throws the dreaded `Type instantiation is excessively deep and possibly infinite. ts(2589)` [error](https://github.com/microsoft/TypeScript/issues/30188#issuecomment-469285102). The types we use are tuned to circumvent this restriction as much as possible.
+2. @strictly transforms the type definitions in multiple ways. The more variation allowed in the base types, the more cases the transformers need to deal with (and the more processing we need to do on those mapped types). Essentially the amount of code you have to write is quadratic (the number of supported type definitions multiplied by the number of transformations). As the number of transformations is potentially unbounded, keeping the number of distinct type definitions to a minimum is key
+
+It's a definite possibility that someone could write an adapter from Zod to our internal type definitions, but it's not practical to use Zod in place of the internal type definitions.
+