pema 0.9.0 → 0.9.2

package/lib/private/JSONType.js

@@ -4,6 +4,14 @@ import OptionalType from "#OptionalType";
 import resolve from "#resolve";
 import Storable from "#Storable";
 import is from "@rcompat/is";
+function json_with_undefined_object_values(x) {
+    if (is.array(x))
+        return x.every(json_with_undefined_object_values);
+    if (is.dict(x)) {
+        return Object.values(x).every(value => is.undefined(value) || json_with_undefined_object_values(value));
+    }
+    return is.json(x);
+}
 export default class JSONType extends Storable {
     #inner;
     constructor(inner) {
@@ -27,8 +35,9 @@ export default class JSONType extends Storable {
         // delegate to inner schema for typed validation
         if (is.defined(this.#inner))
             return this.#inner.parse(x, options);
-        if (!is.json(x))
+        if (!json_with_undefined_object_values(x)) {
             throw E.invalid_type(x, "json", options);
+        }
         return JSON.parse(JSON.stringify(x));
     }
     toJSON() {

package/lib/private/index.d.ts

@@ -149,7 +149,113 @@ declare namespace schema {
     export { loose };
     export { strict };
 }
-declare function loose<const S extends Schema>(s: S): NormalizeSchema<S>;
-declare function strict<const S extends Schema>(s: S): NormalizeSchema<S>;
+declare const loose: (<const S extends Schema>(s: S) => NormalizeSchema<S>) & {
+    array: <const S extends Schema>(of: S) => import("#ArrayType").default<NormalizeSchema<S>, true>;
+    bigint: import("./BigIntType.js").default<"i64", true>;
+    biguint: import("./BigUintType.js").default<"u64", true>;
+    blob: import("#BlobType").default;
+    boolean: import("#BooleanType").default<true>;
+    constructor: <const C extends import("@rcompat/type").AbstractNewable>(c: C) => import("#ConstructorType").default<C>;
+    date: import("#DateType").default<true>;
+    dict: {
+        (): import("#RecordType").default<import("#StringType").default, import("#StringType").default, true>;
+        <const Value extends import("#Parsed").default<unknown>>(of: Value): import("#RecordType").default<import("#StringType").default, Value, true>;
+    };
+    enum: <const V extends import("@rcompat/type").Dict<number>>(values: V) => import("#EnumType").Enum<V, true>;
+    f32: import("#NumberType").default<"f32", true>;
+    f64: import("#NumberType").default<"f64", true>;
+    file: import("./FileType.js").default;
+    function: import("#FunctionType").default;
+    i128: import("./BigIntType.js").default<"i128", true>;
+    i16: import("./IntType.js").default<"i16", true>;
+    i32: import("./IntType.js").default<"i32", true>;
+    i64: import("./BigIntType.js").default<"i64", true>;
+    i8: import("./IntType.js").default<"i8", true>;
+    int: import("./IntType.js").default<"i32", true>;
+    is: <T>(predicate: (x: unknown) => x is T) => import("#IsType").default<T>;
+    json: {
+        (): import("#JSONType").default<undefined>;
+        <S extends import("#JSONType").ParsedJSON>(inner: S): import("#JSONType").default<S>;
+    };
+    literal: <T extends string | number | boolean>(literal: T) => import("#LiteralType").default<T, true>;
+    null: import("#NullType").default;
+    number: import("#NumberType").default<"f64", true>;
+    object: <P extends import("@rcompat/type").Dict<Schema> = import("@rcompat/type").Dict<Schema>>(properties: P) => import("#ObjectType").default<keyof P extends never ? {} : { [K in keyof P]: NormalizeSchema<P[K]>; }, true>;
+    omit: <P extends import("@rcompat/type").Dict<import("#Parsed").default<unknown>>, K extends keyof P>(type: import("#ObjectType").default<P>, ...keys: K[]) => import("./OmitType.js").default<P, K, true>;
+    record: <const Key extends import("./RecordTypeKey.js").default, const Value extends import("#Parsed").default<unknown>>(k: Key, v: Value) => import("#RecordType").default<Key, Value, true>;
+    partial: <const D extends import("./Partialable.js").default>(input: D | import("#ObjectType").default<D>) => import("#PartialType").default<{ -readonly [K in keyof D]: D[K]; }, true>;
+    pure: <T>() => import("#PureType").default<T, "PureType">;
+    string: import("#StringType").default;
+    symbol: import("./SymbolType.js").default;
+    tuple: <const T extends Schema[]>(...items: T) => import("#TupleType").default<{ [K in keyof T]: NormalizeSchema<T[K]>; }, true>;
+    u128: import("./BigUintType.js").default<"u128", true>;
+    u16: import("#UintType").default<"u16", true>;
+    u32: import("#UintType").default<"u32", true>;
+    u64: import("./BigUintType.js").default<"u64", true>;
+    u8: import("#UintType").default<"u8", true>;
+    uint: import("#UintType").default<"u32", true>;
+    undefined: import("#UndefinedType").default;
+    union: {
+        (): import("#UnionType").default<[], true>;
+        <const T extends Schema[]>(...types: T): import("#UnionType").default<{ [K in keyof T]: NormalizeSchema<T[K]>; }, true>;
+    };
+    unknown: import("#UnknownType").default;
+    url: import("#URLType").default<true>;
+    uuid: import("#UUIDType").default;
+};
+declare const strict: (<const S extends Schema>(s: S) => NormalizeSchema<S>) & {
+    array: <const S extends Schema>(of: S) => import("#ArrayType").default<NormalizeSchema<S>, false>;
+    bigint: import("./BigIntType.js").default<"i64", false>;
+    biguint: import("./BigUintType.js").default<"u64", false>;
+    blob: import("#BlobType").default;
+    boolean: import("#BooleanType").default<false>;
+    constructor: <const C extends import("@rcompat/type").AbstractNewable>(c: C) => import("#ConstructorType").default<C>;
+    date: import("#DateType").default<false>;
+    dict: {
+        (): import("#RecordType").default<import("#StringType").default, import("#StringType").default, false>;
+        <const Value extends import("#Parsed").default<unknown>>(of: Value): import("#RecordType").default<import("#StringType").default, Value, false>;
+    };
+    enum: <const V extends import("@rcompat/type").Dict<number>>(values: V) => import("#EnumType").Enum<V, false>;
+    f32: import("#NumberType").default<"f32", false>;
+    f64: import("#NumberType").default<"f64", false>;
+    file: import("./FileType.js").default;
+    function: import("#FunctionType").default;
+    i128: import("./BigIntType.js").default<"i128", false>;
+    i16: import("./IntType.js").default<"i16", false>;
+    i32: import("./IntType.js").default<"i32", false>;
+    i64: import("./BigIntType.js").default<"i64", false>;
+    i8: import("./IntType.js").default<"i8", false>;
+    int: import("./IntType.js").default<"i32", false>;
+    is: <T>(predicate: (x: unknown) => x is T) => import("#IsType").default<T>;
+    json: {
+        (): import("#JSONType").default<undefined>;
+        <S extends import("#JSONType").ParsedJSON>(inner: S): import("#JSONType").default<S>;
+    };
+    literal: <T extends string | number | boolean>(literal: T) => import("#LiteralType").default<T, false>;
+    null: import("#NullType").default;
+    number: import("#NumberType").default<"f64", false>;
+    object: <P extends import("@rcompat/type").Dict<Schema> = import("@rcompat/type").Dict<Schema>>(properties: P) => import("#ObjectType").default<keyof P extends never ? {} : { [K in keyof P]: NormalizeSchema<P[K]>; }, false>;
+    omit: <P extends import("@rcompat/type").Dict<import("#Parsed").default<unknown>>, K extends keyof P>(type: import("#ObjectType").default<P>, ...keys: K[]) => import("./OmitType.js").default<P, K, false>;
+    record: <const Key extends import("./RecordTypeKey.js").default, const Value extends import("#Parsed").default<unknown>>(k: Key, v: Value) => import("#RecordType").default<Key, Value, false>;
+    partial: <const D extends import("./Partialable.js").default>(input: D | import("#ObjectType").default<D>) => import("#PartialType").default<{ -readonly [K in keyof D]: D[K]; }, false>;
+    pure: <T>() => import("#PureType").default<T, "PureType">;
+    string: import("#StringType").default;
+    symbol: import("./SymbolType.js").default;
+    tuple: <const T extends Schema[]>(...items: T) => import("#TupleType").default<{ [K in keyof T]: NormalizeSchema<T[K]>; }, false>;
+    u128: import("./BigUintType.js").default<"u128", false>;
+    u16: import("#UintType").default<"u16", false>;
+    u32: import("#UintType").default<"u32", false>;
+    u64: import("./BigUintType.js").default<"u64", false>;
+    u8: import("#UintType").default<"u8", false>;
+    uint: import("#UintType").default<"u32", false>;
+    undefined: import("#UndefinedType").default;
+    union: {
+        (): import("#UnionType").default<[], false>;
+        <const T extends Schema[]>(...types: T): import("#UnionType").default<{ [K in keyof T]: NormalizeSchema<T[K]>; }, false>;
+    };
+    unknown: import("#UnknownType").default;
+    url: import("#URLType").default<false>;
+    uuid: import("#UUIDType").default;
+};
 export default schema;
 //# sourceMappingURL=index.d.ts.map

package/lib/private/index.js

@@ -51,16 +51,104 @@ import uuid from "#uuid";
 function schema(s) {
     return normalize(s);
 }
-function loose(s) {
+const loose = Object.assign(function loose(s) {
     const i = normalize(s);
     i[Loose] = true;
     return i;
-}
-function strict(s) {
+}, {
+    array: array.loose,
+    bigint: bigint.loose,
+    biguint: biguint.loose,
+    blob: blob.loose,
+    boolean: boolean.loose,
+    constructor: constructor.loose,
+    date: date.loose,
+    dict: dict.loose,
+    enum: enum$.loose,
+    f32: f32.loose,
+    f64: f64.loose,
+    file: file.loose,
+    function: function$.loose,
+    i128: i128.loose,
+    i16: i16.loose,
+    i32: i32.loose,
+    i64: i64.loose,
+    i8: i8.loose,
+    int: int.loose,
+    is: is.loose,
+    json: json.loose,
+    literal: literal.loose,
+    null: null$.loose,
+    number: number.loose,
+    object: object.loose,
+    omit: omit.loose,
+    record: record.loose,
+    partial: partial.loose,
+    pure: pure.loose,
+    string: string.loose,
+    symbol: symbol.loose,
+    tuple: tuple.loose,
+    u128: u128.loose,
+    u16: u16.loose,
+    u32: u32.loose,
+    u64: u64.loose,
+    u8: u8.loose,
+    uint: uint.loose,
+    undefined: undefined$.loose,
+    union: union.loose,
+    unknown: unknown.loose,
+    url: url.loose,
+    uuid: uuid.loose,
+});
+const strict = Object.assign(function strict(s) {
     const i = normalize(s);
     i[Loose] = false;
     return i;
-}
+}, {
+    array: array.strict,
+    bigint: bigint.strict,
+    biguint: biguint.strict,
+    blob: blob.strict,
+    boolean: boolean.strict,
+    constructor: constructor.strict,
+    date: date.strict,
+    dict: dict.strict,
+    enum: enum$.strict,
+    f32: f32.strict,
+    f64: f64.strict,
+    file: file.strict,
+    function: function$.strict,
+    i128: i128.strict,
+    i16: i16.strict,
+    i32: i32.strict,
+    i64: i64.strict,
+    i8: i8.strict,
+    int: int.strict,
+    is: is.strict,
+    json: json.strict,
+    literal: literal.strict,
+    null: null$.strict,
+    number: number.strict,
+    object: object.strict,
+    omit: omit.strict,
+    record: record.strict,
+    partial: partial.strict,
+    pure: pure.strict,
+    string: string.strict,
+    symbol: symbol.strict,
+    tuple: tuple.strict,
+    u128: u128.strict,
+    u16: u16.strict,
+    u32: u32.strict,
+    u64: u64.strict,
+    u8: u8.strict,
+    uint: uint.strict,
+    undefined: undefined$.strict,
+    union: union.strict,
+    unknown: unknown.strict,
+    url: url.strict,
+    uuid: uuid.strict,
+});
 schema.array = array.vanilla;
 schema.async = async_schema;
 schema.bigint = bigint.vanilla;
@@ -106,92 +194,6 @@ schema.unknown = unknown.vanilla;
 schema.url = url.vanilla;
 schema.uuid = uuid.vanilla;
 schema.error = E.field;
-loose.array = array.loose;
-loose.bigint = bigint.loose;
-loose.biguint = biguint.loose;
-loose.blob = blob.loose;
-loose.boolean = boolean.loose;
-loose.constructor = constructor.loose;
-loose.date = date.loose;
-loose.dict = dict.loose;
-loose.enum = enum$.loose;
-loose.f32 = f32.loose;
-loose.f64 = f64.loose;
-loose.file = file.loose;
-loose.function = function$.loose;
-loose.i128 = i128.loose;
-loose.i16 = i16.loose;
-loose.i32 = i32.loose;
-loose.i64 = i64.loose;
-loose.i8 = i8.loose;
-loose.int = int.loose;
-loose.is = is.loose;
-loose.json = json.loose;
-loose.literal = literal.loose;
-loose.null = null$.loose;
-loose.number = number.loose;
-loose.object = object.loose;
-loose.omit = omit.loose;
-loose.record = record.loose;
-loose.partial = partial.loose;
-loose.pure = pure.loose;
-loose.string = string.loose;
-loose.symbol = symbol.loose;
-loose.tuple = tuple.loose;
-loose.u128 = u128.loose;
-loose.u16 = u16.loose;
-loose.u32 = u32.loose;
-loose.u64 = u64.loose;
-loose.u8 = u8.loose;
-loose.uint = uint.loose;
-loose.undefined = undefined$.loose;
-loose.union = union.loose;
-loose.unknown = unknown.loose;
-loose.url = url.loose;
-loose.uuid = uuid.loose;
-strict.array = array.strict;
-strict.bigint = bigint.strict;
-strict.biguint = biguint.strict;
-strict.blob = blob.strict;
-strict.boolean = boolean.strict;
-strict.constructor = constructor.strict;
-strict.date = date.strict;
-strict.dict = dict.strict;
-strict.enum = enum$.strict;
-strict.f32 = f32.strict;
-strict.f64 = f64.strict;
-strict.file = file.strict;
-strict.function = function$.strict;
-strict.i128 = i128.strict;
-strict.i16 = i16.strict;
-strict.i32 = i32.strict;
-strict.i64 = i64.strict;
-strict.i8 = i8.strict;
-strict.int = int.strict;
-strict.is = is.strict;
-strict.json = json.strict;
-strict.literal = literal.strict;
-strict.null = null$.strict;
-strict.number = number.strict;
-strict.object = object.strict;
-strict.omit = omit.strict;
-strict.record = record.strict;
-strict.partial = partial.strict;
-strict.pure = pure.strict;
-strict.string = string.strict;
-strict.symbol = symbol.strict;
-strict.tuple = tuple.strict;
-strict.u128 = u128.strict;
-strict.u16 = u16.strict;
-strict.u32 = u32.strict;
-strict.u64 = u64.strict;
-strict.u8 = u8.strict;
-strict.uint = uint.strict;
-strict.undefined = undefined$.strict;
-strict.union = union.strict;
-strict.unknown = unknown.strict;
-strict.url = url.strict;
-strict.uuid = uuid.strict;
 schema.loose = loose;
 schema.strict = strict;
 export default schema;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pema",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "description": "Primate schema validation",
   "homepage": "https://primate.run/docs/validation",
   "bugs": "https://github.com/primate-run/primate/issues",