@leon740727/type-schema 0.0.3

package/dst/src/check.d.ts

@@ -0,0 +1,3 @@
+import { Optional } from "types";
+import { Schema } from "./type";
+export declare function check(schema: Schema, value: any): Optional<string>;

package/dst/src/check.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.check = void 0;
+const ramda_1 = require("ramda");
+const types_1 = require("types");
+const type_1 = require("./type");
+const util_1 = require("./util");
+function check(schema, value) {
+    return _check(schema, value).map(error2string);
+}
+exports.check = check;
+function error2string(error) {
+    if (error.paths.length > 0) {
+        return `obj.${error.paths.join(".")} ${error.msg}`;
+    }
+    else {
+        return error.msg;
+    }
+}
+function _check(schema, value) {
+    if (value === null && schema.isNullable) {
+        return types_1.Optional.empty();
+    }
+    if (value === undefined && schema.isOptional) {
+        return types_1.Optional.empty();
+    }
+    if (schema.type === type_1.SchemaType.object) {
+        if (typeof value === "object" && value !== null) {
+            // typeof null === 'object'
+            (0, util_1.assert)(schema.innerSchema, "object inner schema is null or undefined");
+            return checkObject(schema.innerSchema, value);
+        }
+        else {
+            return types_1.Optional.of({
+                paths: [],
+                msg: "is not an object",
+            });
+        }
+    }
+    else if (schema.type === type_1.SchemaType.array) {
+        if (value instanceof Array) {
+            return checkArray(schema.itemSchema, value);
+        }
+        else {
+            return types_1.Optional.of({
+                paths: [],
+                msg: "is not an Array",
+            });
+        }
+    }
+    else if (schema.type === type_1.SchemaType.tuple) {
+        if (value instanceof Array) {
+            (0, util_1.assert)(schema.innerSchema, "tuple inner schema is null or undefined");
+            return checkTuple(schema.innerSchema, value);
+        }
+        else {
+            return types_1.Optional.of({
+                paths: [],
+                msg: "is not a tuple",
+            });
+        }
+    }
+    else if (schema.type === type_1.SchemaType.union) {
+        (0, util_1.assert)(schema.innerSchema, "union inner schema is null or undefined");
+        return checkUnion(schema.innerSchema, value);
+    }
+    else {
+        return checkAtom(schema, value);
+    }
+}
+function checkObject(schema, value) {
+    // schema 沒有規範到的欄位不檢查
+    const toChecks = (0, ramda_1.toPairs)(schema)
+        .filter(([field, schema]) => {
+        return (schema.isOptional === false ||
+            (schema.isOptional && value[field] !== undefined));
+    })
+        .map(([field, schema]) => [field, schema]);
+    const errors = toChecks.map(([field, schema]) => {
+        return _check(schema, value[field]).map((error) => ({
+            paths: [field].concat(error.paths),
+            msg: error.msg,
+        }));
+    });
+    return types_1.Optional.of(types_1.Optional.filter(errors)[0]);
+}
+function checkArray(schema, value) {
+    const errors = value.map((v, idx) => {
+        return _check(schema, v).map((error) => (0, util_1.pair)(idx, error));
+    });
+    return types_1.Optional.of(types_1.Optional.filter(errors)[0]).map(([idx, error]) => ({
+        paths: [],
+        msg: `array item ${idx} is wrong (${error2string(error)})`,
+    }));
+}
+function checkTuple(schemas, values) {
+    if (schemas.length !== values.length) {
+        return types_1.Optional.of({ paths: [], msg: "tuple size error" });
+    }
+    else {
+        const errors = (0, ramda_1.zip)(schemas, values).map(([schema, value], idx) => _check(schema, value).map((error) => ({
+            paths: [],
+            msg: `tuple item ${idx} is wrong (${error2string(error)})`,
+        })));
+        return types_1.Optional.of(types_1.Optional.filter(errors)[0]);
+    }
+}
+function checkUnion(schemas, value) {
+    const success = schemas.reduce((success, schema) => {
+        if (success) {
+            return success;
+        }
+        else {
+            const error = _check(schema, value);
+            return (0, ramda_1.not)(error.present);
+        }
+    }, false);
+    if (success) {
+        return types_1.Optional.empty();
+    }
+    else {
+        return types_1.Optional.of({
+            paths: [],
+            msg: "not in union",
+        });
+    }
+}
+function checkAtom(schema, value) {
+    return types_1.Optional.of(schema.isa(value)).map((msg) => ({
+        paths: [],
+        msg,
+    }));
+}

package/dst/src/index.d.ts

@@ -0,0 +1,18 @@
+import { Schema, build } from "./type";
+export { Schema, SchemaType } from "./type";
+export declare const value: typeof Schema.value;
+export declare const object: typeof Schema.object;
+export declare const array: typeof Schema.array;
+export declare const tuple: typeof Schema.tuple;
+export declare const union: typeof Schema.union;
+export type buildType<T extends Schema, transformed extends boolean = true> = build<T, transformed>;
+export declare function check(schema: Schema, value: any): string | null;
+type Result<R> = [string, null] | [null, R];
+export declare function transform<S extends Schema>(schema: S, value: any): Result<build<S, true>>;
+export declare function any(): import("./type").AtomSchema<any, any>;
+export declare function string(): import("./type").AtomSchema<string, string>;
+export declare function number(): import("./type").AtomSchema<number, number>;
+export declare function boolean(): import("./type").AtomSchema<boolean, boolean>;
+export declare function bigint(): import("./type").AtomSchema<bigint, bigint>;
+export declare function date(): import("./type").AtomSchema<Date, Date>;
+export declare function enums<T extends number | string>(valids: T[]): import("./type").AtomSchema<T, T>;

package/dst/src/index.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enums = exports.date = exports.bigint = exports.boolean = exports.number = exports.string = exports.any = exports.transform = exports.check = exports.union = exports.tuple = exports.array = exports.object = exports.value = exports.SchemaType = exports.Schema = void 0;
+const type_1 = require("./type");
+const check_1 = require("./check");
+const transform_1 = require("./transform");
+var type_2 = require("./type");
+Object.defineProperty(exports, "Schema", { enumerable: true, get: function () { return type_2.Schema; } });
+Object.defineProperty(exports, "SchemaType", { enumerable: true, get: function () { return type_2.SchemaType; } });
+exports.value = type_1.Schema.value;
+exports.object = type_1.Schema.object;
+exports.array = type_1.Schema.array;
+exports.tuple = type_1.Schema.tuple;
+exports.union = type_1.Schema.union;
+function check(schema, value) {
+    return (0, check_1.check)(schema, value).orNull();
+}
+exports.check = check;
+function transform(schema, value) {
+    return (0, transform_1.transform)(schema, value).either(
+    //@ts-ignore
+    (error) => [error, null], (value) => [null, value]);
+}
+exports.transform = transform;
+// helper
+function any() {
+    return (0, exports.value)((v) => null);
+}
+exports.any = any;
+function string() {
+    return (0, exports.value)((v) => typeof v === "string" ? null : "is not a string");
+}
+exports.string = string;
+function number() {
+    return (0, exports.value)((v) => typeof v === "number" ? null : "is not a number");
+}
+exports.number = number;
+function boolean() {
+    return (0, exports.value)((v) => typeof v === "boolean" ? null : "is not a boolean");
+}
+exports.boolean = boolean;
+function bigint() {
+    return (0, exports.value)((v) => typeof v === "bigint" ? null : "is not a bigint");
+}
+exports.bigint = bigint;
+function date() {
+    return (0, exports.value)((v) => (v instanceof Date ? null : "is not a Date"));
+}
+exports.date = date;
+function enums(valids) {
+    return type_1.Schema.value((v) => valids.includes(v)
+        ? null
+        : `not a valid enum value, value should be one of [${valids}]`);
+}
+exports.enums = enums;

package/dst/src/transform.d.ts

@@ -0,0 +1,3 @@
+import { Result } from "types";
+import { Schema, build } from "./type";
+export declare function transform<S extends Schema>(schema: S, value: any): Result<string, build<S, true>>;

package/dst/src/transform.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transform = void 0;
+const ramda_1 = require("ramda");
+const types_1 = require("types");
+const type_1 = require("./type");
+const check_1 = require("./check");
+const util_1 = require("./util");
+function transform(schema, value) {
+    return (0, check_1.check)(schema, value)
+        .map((error) => types_1.Result.fail(error))
+        .orExec(() => types_1.Result.ok(_transform(schema, value)));
+}
+exports.transform = transform;
+function _transform(schema, value) {
+    if (value === null) {
+        // check() 已經確認過 null 是合法的
+        return null;
+    }
+    if (value === undefined) {
+        return undefined;
+    }
+    if (schema.type === type_1.SchemaType.atom) {
+        return transformAtom(schema, value);
+    }
+    else if (schema.type === type_1.SchemaType.array) {
+        return transformArray(schema, value);
+    }
+    else if (schema.type === type_1.SchemaType.tuple) {
+        return transformTuple(schema, value);
+    }
+    else if (schema.type === type_1.SchemaType.union) {
+        return transformUnion(schema, value);
+    }
+    else {
+        return transformObject(schema, value);
+    }
+}
+function transformAtom(schema, value) {
+    return schema.transform(value);
+}
+function transformArray(schema, values) {
+    (0, util_1.assert)(schema.type === type_1.SchemaType.array, "");
+    //@ts-ignore
+    return values.map((value) => _transform(schema.itemSchema, value));
+}
+function transformTuple(schema, values) {
+    (0, util_1.assert)(schema.type === type_1.SchemaType.tuple, "");
+    (0, util_1.assert)(schema.innerSchema, "");
+    return (0, ramda_1.zip)(schema.innerSchema, values).map(([schema, value]) => _transform(schema, value));
+}
+function transformUnion(schema, value) {
+    (0, util_1.assert)(schema.type === type_1.SchemaType.union, "");
+    (0, util_1.assert)(schema.innerSchema, "");
+    // 這裡不能用 _transform
+    // 因為 union 裡面的 schema 可能是錯的，但 _transform 假設每一個 schema 都是對的
+    const results = schema.innerSchema.map((schema) => transform(schema, value));
+    const oks = results.filter((i) => i.ok).map((i) => i.orError());
+    (0, util_1.assert)(oks.length > 0, "");
+    return oks[0];
+}
+function transformObject(schema, value) {
+    const innerSchema = schema.innerSchema;
+    (0, util_1.assert)(innerSchema, "object inner schema is null or undefined");
+    const todos = (0, ramda_1.toPairs)(innerSchema)
+        .filter(([field, schema]) => {
+        return (schema.isOptional === false ||
+            (schema.isOptional && value[field] !== undefined));
+    })
+        .map(([field, schema]) => [field, schema]);
+    const v2 = (0, ramda_1.fromPairs)(todos.map(([field, schema]) => (0, util_1.pair)(field, _transform(schema, value[field]))));
+    return (0, ramda_1.mergeRight)(value, v2);
+}

package/dst/src/type.d.ts

@@ -0,0 +1,122 @@
+import { addQuestionMarks, flatten, resolveTuple } from "./util";
+/**
+ * schema 有幾種類別
+ * 1. atom: 沒有 inner schema 描述的值。例如 number, string ...
+ *    注意，array 或 object 也可以是 atom 的，只要其值沒有另外的 schema 描述
+ * 2. compound: 裡面的值有另外的 inner schema 來描述。又分成二種 object, array
+ */
+export declare enum SchemaType {
+    atom = 0,
+    array = 1,
+    object = 2,
+    tuple = 3,
+    union = 4
+}
+type Attr = {
+    [field: string]: any;
+};
+export declare class AtomSchema<VT, VT2> {
+    readonly type: SchemaType.atom;
+    readonly value: VT;
+    readonly isNullable: boolean;
+    readonly isOptional: boolean;
+    readonly isa: (v: any) => string | null;
+    readonly transform: (v: VT) => VT2;
+    readonly attr: Attr;
+    constructor(type: SchemaType.atom, value: VT, isNullable: boolean, isOptional: boolean, isa: (v: any) => string | null, // 傳回錯誤訊息
+    transform: (v: VT) => VT2, attr: Attr);
+    nullable(): AtomSchema<VT | null, VT2>;
+    optional(): AtomSchema<VT | undefined, VT2>;
+    transformer<T2>(fn: (v: NonNullable<VT>) => T2): AtomSchema<VT, T2>;
+    set(attr: Attr): AtomSchema<VT, VT2>;
+}
+export declare class ArraySchema<InnerSchema extends InnerSchemaForArraySchema | null | undefined> {
+    readonly type: SchemaType.array;
+    readonly itemSchema: Schema;
+    readonly isNullable: boolean;
+    readonly isOptional: boolean;
+    readonly attr: Attr;
+    readonly innerSchema: InnerSchema;
+    constructor(type: SchemaType.array, itemSchema: Schema, isNullable: boolean, isOptional: boolean, attr: Attr);
+    nullable(): ArraySchema<InnerSchema | null>;
+    optional(): ArraySchema<InnerSchema | undefined>;
+    set(attr: Attr): ArraySchema<InnerSchema>;
+}
+export declare class ObjectSchema<InnerSchema extends InnerSchemaForObjectSchema | null | undefined> {
+    readonly type: SchemaType.object;
+    readonly innerSchema: InnerSchema;
+    readonly isNullable: boolean;
+    readonly isOptional: boolean;
+    readonly attr: Attr;
+    constructor(type: SchemaType.object, innerSchema: InnerSchema, isNullable: boolean, isOptional: boolean, attr: Attr);
+    nullable(): ObjectSchema<InnerSchema | null>;
+    optional(): ObjectSchema<InnerSchema | undefined>;
+    set(attr: Attr): ObjectSchema<InnerSchema>;
+}
+declare class TupleSchema<InnerSchema extends [Schema, ...Schema[]] | null | undefined> {
+    readonly type: SchemaType.tuple;
+    readonly innerSchema: InnerSchema;
+    readonly isNullable: boolean;
+    readonly isOptional: boolean;
+    readonly attr: Attr;
+    constructor(type: SchemaType.tuple, innerSchema: InnerSchema, isNullable: boolean, isOptional: boolean, attr: Attr);
+    nullable(): TupleSchema<InnerSchema | null>;
+    optional(): TupleSchema<InnerSchema | undefined>;
+    set(attr: Attr): TupleSchema<InnerSchema>;
+}
+declare class UnionSchema<InnerSchema extends Schema[] | null | undefined> {
+    readonly type: SchemaType.union;
+    readonly innerSchema: InnerSchema;
+    readonly isNullable: boolean;
+    readonly isOptional: boolean;
+    readonly attr: Attr;
+    constructor(type: SchemaType.union, innerSchema: InnerSchema, isNullable: boolean, isOptional: boolean, attr: Attr);
+    nullable(): UnionSchema<InnerSchema | null>;
+    optional(): UnionSchema<InnerSchema | undefined>;
+    set(attr: Attr): UnionSchema<InnerSchema>;
+}
+export type Schema = AtomSchema<any, any> | ArraySchema<InnerSchemaForArraySchema | null | undefined> | TupleSchema<[Schema, ...Schema[]] | null | undefined> | UnionSchema<Schema[] | null | undefined> | ObjectSchema<InnerSchemaForObjectSchema | null | undefined>;
+type InnerSchemaForArraySchema = Schema[];
+export type InnerSchemaForObjectSchema = {
+    [field: string]: Schema;
+};
+export declare namespace Schema {
+    function value<T>(isa: (v: any) => string | null): AtomSchema<T, T>;
+    function array<S extends Schema>(itemSchema: S): ArraySchema<S[]>;
+    function object<S extends InnerSchemaForObjectSchema>(innerSchema: S): ObjectSchema<S>;
+    function tuple<tuple extends [Schema, ...Schema[]]>(schemas: tuple): TupleSchema<tuple>;
+    function union<union extends Schema[]>(schemas: union): UnionSchema<union>;
+}
+export type fetchAtom<T extends Schema> = T extends {
+    type: SchemaType.atom;
+} ? T : never;
+export type fetchArray<T extends Schema> = T extends {
+    type: SchemaType.array;
+} ? T : never;
+export type fetchObject<T extends Schema> = T extends {
+    type: SchemaType.object;
+} ? T : never;
+export type fetchTuple<T extends Schema> = Extract<T, TupleSchema<any>>;
+export type fetchUnion<T extends Schema> = Extract<T, UnionSchema<any>>;
+export type build<S extends Schema, transformed extends boolean> = S extends {
+    type: SchemaType.object;
+} ? buildObj<fetchObject<S>["innerSchema"], transformed> : S extends {
+    type: SchemaType.array;
+} ? buildArray<fetchArray<S>["innerSchema"], transformed> : S extends {
+    type: SchemaType.tuple;
+} ? buildTuple<fetchTuple<S>["innerSchema"], transformed> : S extends {
+    type: SchemaType.union;
+} ? buildUnion<fetchUnion<S>["innerSchema"], transformed> : S extends {
+    type: SchemaType.atom;
+} ? buildAtom<fetchAtom<S>, transformed> : never;
+type buildObj<OS extends InnerSchemaForObjectSchema | null | undefined, transformed extends boolean> = OS extends InnerSchemaForObjectSchema ? flatten<addQuestionMarks<{
+    [f in keyof OS]: build<OS[f], transformed>;
+}>> : OS;
+type buildArray<S extends InnerSchemaForArraySchema | null | undefined, transformed extends boolean> = S extends InnerSchemaForArraySchema ? build<S[number], transformed>[] : S;
+type buildTuple<S extends any[] | null | undefined, transformed extends boolean> = S extends [Schema, ...Schema[]] ? [
+    build<resolveTuple<S>[0], transformed>,
+    ...buildTuple<resolveTuple<S>[1], transformed>
+] : S;
+type buildUnion<S extends Schema[] | null | undefined, transformed extends boolean> = S extends Schema[] ? build<S[number], transformed> : S;
+type buildAtom<S extends Schema | null | undefined, transformed extends boolean> = S extends Schema ? transformed extends true ? ReturnType<fetchAtom<S>["transform"]> | Extract<fetchAtom<S>["value"], null | undefined> : fetchAtom<S>["value"] : S;
+export {};

package/dst/src/type.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Schema = exports.ObjectSchema = exports.ArraySchema = exports.AtomSchema = exports.SchemaType = void 0;
+const ramda_1 = require("ramda");
+/**
+ * schema 有幾種類別
+ * 1. atom: 沒有 inner schema 描述的值。例如 number, string ...
+ *    注意，array 或 object 也可以是 atom 的，只要其值沒有另外的 schema 描述
+ * 2. compound: 裡面的值有另外的 inner schema 來描述。又分成二種 object, array
+ */
+var SchemaType;
+(function (SchemaType) {
+    SchemaType[SchemaType["atom"] = 0] = "atom";
+    SchemaType[SchemaType["array"] = 1] = "array";
+    SchemaType[SchemaType["object"] = 2] = "object";
+    SchemaType[SchemaType["tuple"] = 3] = "tuple";
+    SchemaType[SchemaType["union"] = 4] = "union";
+})(SchemaType = exports.SchemaType || (exports.SchemaType = {}));
+class AtomSchema {
+    constructor(type, value, isNullable, isOptional, isa, // 傳回錯誤訊息
+    transform, attr // 額外附加的屬性
+    ) {
+        this.type = type;
+        this.value = value;
+        this.isNullable = isNullable;
+        this.isOptional = isOptional;
+        this.isa = isa;
+        this.transform = transform;
+        this.attr = attr;
+    }
+    nullable() {
+        return new AtomSchema(SchemaType.atom, this.value, true, this.isOptional, this.isa, this.transform, this.attr);
+    }
+    optional() {
+        return new AtomSchema(SchemaType.atom, this.value, this.isNullable, true, this.isa, this.transform, this.attr);
+    }
+    transformer(fn) {
+        return new AtomSchema(SchemaType.atom, this.value, this.isNullable, this.isOptional, this.isa, fn, this.attr);
+    }
+    set(attr) {
+        const newAttr = (0, ramda_1.mergeRight)(this.attr, attr);
+        return new AtomSchema(SchemaType.atom, this.value, this.isNullable, this.isOptional, this.isa, this.transform, newAttr);
+    }
+}
+exports.AtomSchema = AtomSchema;
+class ArraySchema {
+    constructor(type, itemSchema, isNullable, isOptional, attr // 額外附加的屬性
+    ) {
+        this.type = type;
+        this.itemSchema = itemSchema;
+        this.isNullable = isNullable;
+        this.isOptional = isOptional;
+        this.attr = attr;
+    }
+    nullable() {
+        return new ArraySchema(SchemaType.array, this.itemSchema, true, this.isOptional, this.attr);
+    }
+    optional() {
+        return new ArraySchema(SchemaType.array, this.itemSchema, this.isNullable, true, this.attr);
+    }
+    set(attr) {
+        const newAttr = (0, ramda_1.mergeRight)(this.attr, attr);
+        return new ArraySchema(SchemaType.array, this.itemSchema, this.isNullable, this.isOptional, newAttr);
+    }
+}
+exports.ArraySchema = ArraySchema;
+class ObjectSchema {
+    constructor(type, innerSchema, isNullable, isOptional, attr // 額外附加的屬性
+    ) {
+        this.type = type;
+        this.innerSchema = innerSchema;
+        this.isNullable = isNullable;
+        this.isOptional = isOptional;
+        this.attr = attr;
+    }
+    nullable() {
+        return new ObjectSchema(SchemaType.object, this.innerSchema, true, this.isOptional, this.attr);
+    }
+    optional() {
+        return new ObjectSchema(SchemaType.object, this.innerSchema, this.isNullable, true, this.attr);
+    }
+    set(attr) {
+        const newAttr = (0, ramda_1.mergeRight)(this.attr, attr);
+        return new ObjectSchema(SchemaType.object, this.innerSchema, this.isNullable, this.isOptional, newAttr);
+    }
+}
+exports.ObjectSchema = ObjectSchema;
+class TupleSchema {
+    constructor(type, innerSchema, isNullable, isOptional, attr // 額外附加的屬性
+    ) {
+        this.type = type;
+        this.innerSchema = innerSchema;
+        this.isNullable = isNullable;
+        this.isOptional = isOptional;
+        this.attr = attr;
+    }
+    nullable() {
+        return new TupleSchema(SchemaType.tuple, this.innerSchema, true, this.isOptional, this.attr);
+    }
+    optional() {
+        return new TupleSchema(SchemaType.tuple, this.innerSchema, this.isNullable, true, this.attr);
+    }
+    set(attr) {
+        const newAttr = (0, ramda_1.mergeRight)(this.attr, attr);
+        return new TupleSchema(SchemaType.tuple, this.innerSchema, this.isNullable, this.isOptional, newAttr);
+    }
+}
+class UnionSchema {
+    constructor(type, innerSchema, isNullable, isOptional, attr // 額外附加的屬性
+    ) {
+        this.type = type;
+        this.innerSchema = innerSchema;
+        this.isNullable = isNullable;
+        this.isOptional = isOptional;
+        this.attr = attr;
+    }
+    nullable() {
+        return new UnionSchema(SchemaType.union, this.innerSchema, true, this.isOptional, this.attr);
+    }
+    optional() {
+        return new UnionSchema(SchemaType.union, this.innerSchema, this.isNullable, true, this.attr);
+    }
+    set(attr) {
+        const newAttr = (0, ramda_1.mergeRight)(this.attr, attr);
+        return new UnionSchema(SchemaType.union, this.innerSchema, this.isNullable, this.isOptional, newAttr);
+    }
+}
+var Schema;
+(function (Schema) {
+    function value(isa) {
+        return new AtomSchema(SchemaType.atom, null, false, false, isa, (v) => v, {});
+    }
+    Schema.value = value;
+    function array(itemSchema) {
+        return new ArraySchema(SchemaType.array, itemSchema, false, false, {});
+    }
+    Schema.array = array;
+    function object(innerSchema) {
+        return new ObjectSchema(SchemaType.object, innerSchema, false, false, {});
+    }
+    Schema.object = object;
+    function tuple(schemas) {
+        return new TupleSchema(SchemaType.tuple, schemas, false, false, {});
+    }
+    Schema.tuple = tuple;
+    function union(schemas) {
+        return new UnionSchema(SchemaType.union, schemas, false, false, {});
+    }
+    Schema.union = union;
+})(Schema = exports.Schema || (exports.Schema = {}));

package/dst/src/util.d.ts

@@ -0,0 +1,19 @@
+export type flatten<T> = identity<{
+    [k in keyof T]: T[k];
+}>;
+export type addQuestionMarks<T extends object> = {
+    [K in requiredKeys<T>]: T[K];
+} & {
+    [K in optionalKeys<T>]?: T[K];
+};
+export type resolveTuple<tuple> = tuple extends [infer h, ...infer r] ? [h, r] : never;
+type identity<T> = T;
+type optionalKeys<T extends object> = {
+    [k in keyof T]: undefined extends T[k] ? k : never;
+}[keyof T];
+type requiredKeys<T extends object> = {
+    [k in keyof T]: undefined extends T[k] ? never : k;
+}[keyof T];
+export declare function assert(condition: unknown, message: string): asserts condition;
+export declare function pair<A, B>(a: A, b: B): [A, B];
+export {};

package/dst/src/util.js

@@ -0,0 +1,16 @@
+"use strict";
+// ref: https://github.com/colinhacks/zod
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pair = exports.assert = void 0;
+class AssertError extends Error {
+}
+function assert(condition, message) {
+    if (!condition) {
+        throw new AssertError(message);
+    }
+}
+exports.assert = assert;
+function pair(a, b) {
+    return [a, b];
+}
+exports.pair = pair;

package/dst/test/enums.d.ts

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

package/dst/test/enums.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = require("assert");
+const Schema = require("../src/index");
+describe("enums", () => {
+    const schema = Schema.enums([1, 2, "yes", "no"]);
+    it("type", () => {
+        const t1 = 1;
+        const t2 = 2;
+        const t3 = "yes";
+        const t4 = "no";
+        //@ts-expect-error
+        const t5 = 3;
+        //@ts-expect-error
+        const t6 = "error";
+    });
+    it("transform", () => {
+        assert.strictEqual(Schema.transform(schema, 2)[0], null);
+        assert.strictEqual(Schema.transform(schema, 3)[0], "not a valid enum value, value should be one of [1,2,yes,no]");
+        assert.strictEqual(Schema.transform(schema, "e")[0], "not a valid enum value, value should be one of [1,2,yes,no]");
+    });
+});

package/dst/test/nullable.d.ts

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