pema 0.4.0 → 0.6.0

package/lib/private/coerce/float.d.ts

@@ -0,0 +1,2 @@
+export default function coerceFloat(x: unknown): unknown;
+//# sourceMappingURL=float.d.ts.map

package/lib/private/coerce/float.js

@@ -0,0 +1,8 @@
+import is from "@rcompat/is";
+export default function coerceFloat(x) {
+    const n = is.numeric(x) ? Number(x) : x;
+    if (is.number(n))
+        return n;
+    return x;
+}
+//# sourceMappingURL=float.js.map

package/lib/private/coerce/int.d.ts

@@ -1,2 +1,2 @@
-export default function coerceInt(x: unknown): unknown;
+export default function coerce_int(x: unknown): unknown;
 //# sourceMappingURL=int.d.ts.map

package/lib/private/coerce/int.js

@@ -1,8 +1,10 @@
-import numeric from "@rcompat/is/numeric";
-export default function coerceInt(x) {
-    if (numeric(x)) {
-        return Number(x);
-    }
+import is from "@rcompat/is";
+export default function coerce_int(x) {
+    // normalize from string to number; other types unaffected
+    const n = is.numeric(x) ? Number(x) : x;
+    // if is integer, return it
+    if (typeof n === "number" && is.int(n))
+        return n;
     return x;
 }
 //# sourceMappingURL=int.js.map

package/lib/private/constructor.d.ts

@@ -1,5 +1,5 @@
 import ConstructorType from "#ConstructorType";
-import type AbstractNewable from "@rcompat/type/AbstractNewable";
+import type { AbstractNewable } from "@rcompat/type";
 /**
  * Value is a constructed instance of the given class.
  */

package/lib/private/dict.d.ts

@@ -0,0 +1,11 @@
+import type Parsed from "#Parsed";
+import type RecordType from "#RecordType";
+import type StringType from "#StringType";
+/**
+ * Value is a dictionary (record with string keys) of the given type.
+ *
+ * @param of - The value type (defaults to p.string)
+ */
+export default function dict(): RecordType<StringType, StringType>;
+export default function dict<const Value extends Parsed<unknown>>(of: Value): RecordType<StringType, Value>;
+//# sourceMappingURL=dict.d.ts.map

package/lib/private/dict.js

@@ -0,0 +1,6 @@
+import record from "#record";
+import string from "#string";
+export default function dict(of = string) {
+    return record(string, of);
+}
+//# sourceMappingURL=dict.js.map

package/lib/private/enum.d.ts

@@ -0,0 +1,3 @@
+import EnumType from "#EnumType";
+export default function _enum<T extends readonly string[]>(values: T): EnumType<T>;
+//# sourceMappingURL=enum.d.ts.map

package/lib/private/enum.js

@@ -0,0 +1,5 @@
+import EnumType from "#EnumType";
+export default function _enum(values) {
+    return new EnumType(values);
+}
+//# sourceMappingURL=enum.js.map

package/lib/private/errors.d.ts

@@ -0,0 +1,21 @@
+import ParseError from "#ParseError";
+import type ParseOptions from "#ParseOptions";
+import type { JSONPointer } from "@rcompat/type";
+declare function invalid_type(input: unknown, expected: string, options?: ParseOptions<any> | JSONPointer): ParseError;
+declare function invalid_format(input: unknown, message: string, path?: JSONPointer): ParseError;
+declare function too_small(input: unknown, message: string, path?: JSONPointer): ParseError;
+declare function too_large(input: unknown, message: string, path?: JSONPointer): ParseError;
+declare function out_of_range(input: unknown, message: string, path?: JSONPointer): ParseError;
+declare function duplicate(input: unknown, message: string, path?: JSONPointer): ParseError;
+declare function not_in_set(input: unknown, message: string, path?: JSONPointer): ParseError;
+declare const _default: {
+    invalid_type: typeof invalid_type;
+    invalid_format: typeof invalid_format;
+    too_small: typeof too_small;
+    too_large: typeof too_large;
+    out_of_range: typeof out_of_range;
+    duplicate: typeof duplicate;
+    not_in_set: typeof not_in_set;
+};
+export default _default;
+//# sourceMappingURL=errors.d.ts.map

package/lib/private/errors.js

@@ -0,0 +1,53 @@
+import ParsedKey from "#ParsedKey";
+import ParseError from "#ParseError";
+function print_got(x) {
+    if (x === undefined)
+        return "undefined";
+    if (x === null)
+        return "null";
+    return `\`${x?.toString() ?? x}\` (${typeof x})`;
+}
+function invalid_type(input, expected, options = "") {
+    const path = typeof options === "string"
+        ? options
+        : options[ParsedKey] ?? "";
+    return new ParseError([{
+            type: "invalid_type",
+            input,
+            message: `expected ${expected}, got ${print_got(input)}`,
+            path,
+        }]);
+}
+function invalid_format(input, message, path = "") {
+    return new ParseError([{
+            type: "invalid_format",
+            input,
+            message,
+            path,
+        }]);
+}
+function too_small(input, message, path = "") {
+    return new ParseError([{ type: "too_small", input, message, path }]);
+}
+function too_large(input, message, path = "") {
+    return new ParseError([{ type: "too_large", input, message, path }]);
+}
+function out_of_range(input, message, path = "") {
+    return new ParseError([{ type: "out_of_range", input, message, path }]);
+}
+function duplicate(input, message, path = "") {
+    return new ParseError([{ type: "duplicate", input, message, path }]);
+}
+function not_in_set(input, message, path = "") {
+    return new ParseError([{ type: "not_in_set", input, message, path }]);
+}
+export default {
+    invalid_type,
+    invalid_format,
+    too_small,
+    too_large,
+    out_of_range,
+    duplicate,
+    not_in_set,
+};
+//# sourceMappingURL=errors.js.map

package/lib/private/function.d.ts

@@ -0,0 +1,7 @@
+import FunctionType from "#FunctionType";
+/**
+ * Value is a function.
+ */
+declare const _default: FunctionType;
+export default _default;
+//# sourceMappingURL=function.d.ts.map

package/lib/private/function.js

@@ -0,0 +1,6 @@
+import FunctionType from "#FunctionType";
+/**
+ * Value is a function.
+ */
+export default new FunctionType();
+//# sourceMappingURL=function.js.map

package/lib/private/index.d.ts

@@ -1,3 +1,42 @@
+export type { default as ArrayType } from "#ArrayType";
+export type { default as BooleanType } from "#BooleanType";
+export type { default as ConstructorType } from "#ConstructorType";
+export type { default as DataKey } from "#DataKey";
+export type { default as DataType } from "#DataType";
+export type { default as DateType } from "#DateType";
+export type { default as DefaultType } from "#DefaultType";
+export type { default as EnumType } from "#EnumType";
+export type { default as FunctionType } from "#FunctionType";
+export type { default as Id } from "#Id";
+export type { default as InferStore } from "#InferStore";
+export type { default as InferStoreOut } from "#InferStoreOut";
+export type { default as Issue } from "#Issue";
+export type { default as IsType } from "#IsType";
+export type { default as JSONPayload } from "#json/JSONPayload";
+export type { default as LiteralType } from "#LiteralType";
+export type { default as NormalizeSchema, NormalizeSchemaObject } from "#NormalizeSchema";
+export type { default as NullType } from "#NullType";
+export type { default as NumberType } from "#NumberType";
+export type { default as ObjectType } from "#ObjectType";
+export type { default as OptionalType } from "#OptionalType";
+export type { default as Parsed } from "#Parsed";
+export type { default as PureType } from "#PureType";
+export type { default as RecordType } from "#RecordType";
+export type { default as Schema } from "#Schema";
+export type { default as Serialized } from "#Serialized";
+export type { default as Storable } from "#Storable";
+export type { default as StoreId } from "#StoreId";
+export type { default as StoreSchema } from "#StoreSchema";
+export type { default as StringType } from "#StringType";
+export type { default as TupleType } from "#TupleType";
+export type { default as UintType } from "#UintType";
+export type { default as UndefinedType } from "#UndefinedType";
+export type { default as UnionType } from "#UnionType";
+export type { default as UnknownType } from "#UnknownType";
+export type { default as UUIDType } from "#UUIDType";
+export type { default as UUIDV4Type } from "#UUIDV4Type";
+export type { default as UUIDV7Type } from "#UUIDV7Type";
+import enum_ from "#enum";
 import type NormalizeSchema from "#NormalizeSchema";
 import type Schema from "#Schema";
 /**
@@ -5,36 +44,46 @@ import type Schema from "#Schema";
 */
 declare function schema<const S extends Schema>(s: S): NormalizeSchema<S>;
 declare namespace schema {
-    var array: typeof import("#array").default;
-    var bigint: import("./BigIntType.js").default<"i64">;
-    var biguint: import("./BigUintType.js").default<"u64">;
-    var blob: import("./BlobType.js").default;
-    var boolean: import("./BooleanType.js").default;
-    var constructor: <const C extends import("@rcompat/type/AbstractNewable").default>(constructor: C) => import("./ConstructorType.js").default<C>;
-    var date: import("./DateType.js").default;
-    var f32: import("./NumberType.js").default<"f32">;
-    var f64: import("./NumberType.js").default<"f64">;
-    var file: import("./FileType.js").default;
-    var i128: import("./BigIntType.js").default<"i128">;
-    var i16: import("./IntType.js").default<"i16">;
-    var i32: import("./IntType.js").default<"i32">;
-    var i64: import("./BigIntType.js").default<"i64">;
-    var i8: import("./IntType.js").default<"i8">;
-    var int: import("./IntType.js").default<"i32">;
-    var number: import("./NumberType.js").default<"f64">;
-    var omit: typeof import("#omit").default;
-    var record: <const Key extends import("./RecordTypeKey.js").default, const Value extends import("./Parsed.js").default<unknown>>(k: Key, v: Value) => import("./RecordType.js").default<Key, Value>;
-    var primary: import("./PrimaryType.js").default;
-    var string: import("./StringType.js").default;
-    var symbol: import("./SymbolType.js").default;
-    var u128: import("./BigUintType.js").default<"u128">;
-    var u16: import("./UintType.js").default<"u16">;
-    var u32: import("./UintType.js").default<"u32">;
-    var u64: import("./BigUintType.js").default<"u64">;
-    var u8: import("./UintType.js").default<"u8">;
-    var uint: import("./UintType.js").default<"u32">;
-    var union: typeof import("#union").default;
-    var unknown: import("./UnknownType.js").default;
+    export var array: typeof import("#array").default;
+    export var bigint: import("./BigIntType.js").default<"i64">;
+    export var biguint: import("./BigUintType.js").default<"u64">;
+    export var blob: import("./BlobType.js").default;
+    export var boolean: import("#BooleanType").default;
+    export var constructor: <const C extends import("@rcompat/type").AbstractNewable>(constructor: C) => import("#ConstructorType").default<C>;
+    export var date: import("#DateType").default;
+    export var dict: typeof import("#dict").default;
+    var _a: typeof enum_;
+    export var f32: import("#NumberType").default<"f32">;
+    export var f64: import("#NumberType").default<"f64">;
+    export var file: import("./FileType.js").default;
+    var _b: import("#FunctionType").default;
+    export var i128: import("./BigIntType.js").default<"i128">;
+    export var i16: import("./IntType.js").default<"i16">;
+    export var i32: import("./IntType.js").default<"i32">;
+    export var i64: import("./BigIntType.js").default<"i64">;
+    export var i8: import("./IntType.js").default<"i8">;
+    export var int: import("./IntType.js").default<"i32">;
+    export var is: <T>(predicate: (x: unknown) => x is T) => import("#IsType").default<T>;
+    export var json: typeof import("#json").default;
+    export var number: import("#NumberType").default<"f64">;
+    export var object: typeof import("#object").default;
+    export var omit: typeof import("#omit").default;
+    export var record: <const Key extends import("./RecordTypeKey.js").default, const Value extends import("#Parsed").default<unknown>>(k: Key, v: Value) => import("#RecordType").default<Key, Value>;
+    export var pure: typeof import("#pure").default;
+    export var string: import("#StringType").default;
+    export var symbol: import("./SymbolType.js").default;
+    export var tuple: typeof import("#tuple").default;
+    export var u128: import("./BigUintType.js").default<"u128">;
+    export var u16: import("#UintType").default<"u16">;
+    export var u32: import("#UintType").default<"u32">;
+    export var u64: import("./BigUintType.js").default<"u64">;
+    export var u8: import("#UintType").default<"u8">;
+    export var uint: import("#UintType").default<"u32">;
+    export var union: typeof import("#union").default;
+    export var unknown: import("#UnknownType").default;
+    export var url: import("./URLType.js").default;
+    export var uuid: import("#UUIDType").default;
+    export { _a as enum, _b as function };
 }
 export default schema;
 //# sourceMappingURL=index.d.ts.map

package/lib/private/index.js

@@ -5,22 +5,29 @@ import blob from "#blob";
 import boolean from "#boolean";
 import constructor from "#constructor";
 import date from "#date";
+import dict from "#dict";
+import enum_ from "#enum";
 import f32 from "#f32";
 import f64 from "#f64";
 import file from "#file";
+import fn from "#function";
 import i128 from "#i128";
 import i16 from "#i16";
 import i32 from "#i32";
 import i64 from "#i64";
 import i8 from "#i8";
 import int from "#int";
+import is from "#is";
+import json from "#json";
 import normalize from "#normalize";
 import number from "#number";
+import object from "#object";
 import omit from "#omit";
-import primary from "#primary";
+import pure from "#pure";
 import record from "#record";
 import string from "#string";
 import symbol from "#symbol";
+import tuple from "#tuple";
 import u128 from "#u128";
 import u16 from "#u16";
 import u32 from "#u32";
@@ -29,6 +36,8 @@ import u8 from "#u8";
 import uint from "#uint";
 import union from "#union";
 import unknown from "#unknown";
+import url from "#url";
+import uuid from "#uuid";
 /**
 * Create a schema.
 */
@@ -42,21 +51,28 @@ schema.blob = blob;
 schema.boolean = boolean;
 schema.constructor = constructor;
 schema.date = date;
+schema.dict = dict;
+schema.enum = enum_;
 schema.f32 = f32;
 schema.f64 = f64;
 schema.file = file;
+schema.function = fn;
 schema.i128 = i128;
 schema.i16 = i16;
 schema.i32 = i32;
 schema.i64 = i64;
 schema.i8 = i8;
 schema.int = int;
+schema.is = is;
+schema.json = json;
 schema.number = number;
+schema.object = object;
 schema.omit = omit;
 schema.record = record;
-schema.primary = primary;
+schema.pure = pure;
 schema.string = string;
 schema.symbol = symbol;
+schema.tuple = tuple;
 schema.u128 = u128;
 schema.u16 = u16;
 schema.u32 = u32;
@@ -65,5 +81,7 @@ schema.u8 = u8;
 schema.uint = uint;
 schema.union = union;
 schema.unknown = unknown;
+schema.url = url;
+schema.uuid = uuid;
 export default schema;
 //# sourceMappingURL=index.js.map

package/lib/private/is.d.ts

@@ -0,0 +1,4 @@
+import IsType from "#IsType";
+declare const _default: <T>(predicate: (x: unknown) => x is T) => IsType<T>;
+export default _default;
+//# sourceMappingURL=is.d.ts.map

package/lib/private/is.js

@@ -0,0 +1,3 @@
+import IsType from "#IsType";
+export default (predicate) => new IsType(predicate);
+//# sourceMappingURL=is.js.map

package/lib/private/json/JSONIssue.d.ts

@@ -1,4 +1,6 @@
+import type IssueType from "#IssueType";
 type JSONIssue = {
+    type: IssueType;
     message: string;
     messages: string[];
 };

package/lib/private/json/JSONPayload.d.ts

@@ -1,5 +1,5 @@
 import type JSONIssue from "#json/JSONIssue";
-import type JSONPointer from "@rcompat/type/JSONPointer";
+import type { JSONPointer } from "@rcompat/type";
 type JSONPayload = JSONIssue | Record<JSONPointer, JSONIssue>;
 export type { JSONPayload as default };
 //# sourceMappingURL=JSONPayload.d.ts.map

package/lib/private/json.d.ts

@@ -0,0 +1,5 @@
+import type { ParsedJSON } from "#JSONType";
+import JSONType from "#JSONType";
+export default function json(): JSONType<undefined>;
+export default function json<S extends ParsedJSON>(inner: S): JSONType<S>;
+//# sourceMappingURL=json.d.ts.map

package/lib/private/json.js

@@ -0,0 +1,5 @@
+import JSONType from "#JSONType";
+export default function json(inner) {
+    return new JSONType(inner);
+}
+//# sourceMappingURL=json.js.map

package/lib/private/normalize.js

@@ -6,7 +6,7 @@ import ObjectType from "#ObjectType";
 import ParsedKey from "#ParsedKey";
 import TupleType from "#TupleType";
 import UndefinedType from "#UndefinedType";
-import newable from "@rcompat/is/newable";
+import is from "@rcompat/is";
 function isParsed(x) {
     return !!x && typeof x === "object" && ParsedKey in x;
 }
@@ -23,9 +23,8 @@ export default function normalize(x) {
         return new UndefinedType();
     if (typeof x === "string" || typeof x === "number" || typeof x === "boolean")
         return new LiteralType(x);
-    if (newable(x)) {
+    if (is.newable(x))
         return new ConstructorType(x);
-    }
     if (Array.isArray(x)) {
         return x.length === 1
             ? new ArrayType(normalize(x[0]))

package/lib/private/object.d.ts

@@ -1,11 +1,10 @@
 import type NormalizeSchema from "#NormalizeSchema";
 import ObjectType from "#ObjectType";
 import type Schema from "#Schema";
-import type Dict from "@rcompat/type/Dict";
-import type EO from "@rcompat/type/EO";
-type NormalizeProps<S extends Dict<Schema>> = keyof S extends never ? EO : {
+import type { Dict, EmptyObject } from "@rcompat/type";
+type NormalizeProps<S extends Dict<Schema>> = keyof S extends never ? EmptyObject : {
     [K in keyof S]: NormalizeSchema<S[K]>;
 };
-export default function object<P extends Dict<Schema>>(properties: P): ObjectType<NormalizeProps<P>>;
+export default function object<P extends Dict<Schema> = Dict<Schema>>(properties: P): ObjectType<NormalizeProps<P>>;
 export {};
 //# sourceMappingURL=object.d.ts.map

package/lib/private/object.js

@@ -1,8 +1,8 @@
 import normalize from "#normalize";
 import ObjectType from "#ObjectType";
-export default function object(peries) {
+export default function object(properties) {
     const props = {};
-    for (const [k, v] of Object.entries(peries)) {
+    for (const [k, v] of Object.entries(properties)) {
         props[k] = normalize(v);
     }
     return new ObjectType(props);

package/lib/private/omit.d.ts

@@ -1,6 +1,6 @@
 import type ObjectType from "#ObjectType";
 import OmitType from "#OmitType";
 import type Parsed from "#Parsed";
-import type Dict from "@rcompat/type/Dict";
+import type { Dict } from "@rcompat/type";
 export default function omit<P extends Dict<Parsed<unknown>>, K extends keyof P>(type: ObjectType<P>, ...keys: K[]): OmitType<P, K>;
 //# sourceMappingURL=omit.d.ts.map

package/lib/private/path/join.d.ts

@@ -1,3 +1,3 @@
-import type JSONPointer from "@rcompat/type/JSONPointer";
+import type { JSONPointer } from "@rcompat/type";
 export default function join(base: JSONPointer, ...tokens: (number | string)[]): JSONPointer;
 //# sourceMappingURL=join.d.ts.map

package/lib/private/path/next.d.ts

@@ -1,7 +1,7 @@
 import ParsedKey from "#ParsedKey";
 import type ParseOptions from "#ParseOptions";
 export default function next(s: number | string, options?: ParseOptions): {
-    [ParsedKey]: import("@rcompat/type/JSONPointer").default;
+    [ParsedKey]: import("@rcompat/type").JSONPointer;
     coerce?: boolean;
     partial?: boolean;
     validators?: import("../Validator.js").default<unknown>[] | undefined;

package/lib/private/path/rebase.d.ts

@@ -1,3 +1,3 @@
-import type JSONPointer from "@rcompat/type/JSONPointer";
+import type { JSONPointer } from "@rcompat/type";
 export default function rebase(base: JSONPointer, rel: JSONPointer): JSONPointer;
 //# sourceMappingURL=rebase.d.ts.map

package/lib/private/schema-errors.d.ts

@@ -0,0 +1,16 @@
+declare const errors: {
+    unique_subtype_not_primitive: (subtype: string) => import("@rcompat/error").TemplateError;
+    min_negative: (limit: number) => import("@rcompat/error").TemplateError;
+    max_negative: (limit: number) => import("@rcompat/error").TemplateError;
+    length_not_finite: (from: number, to: number) => import("@rcompat/error").TemplateError;
+    length_not_positive: (from: number, to: number) => import("@rcompat/error").TemplateError;
+    length_from_exceeds_to: (from: number, to: number) => import("@rcompat/error").TemplateError;
+    min_limit_not_finite: (limit: number) => import("@rcompat/error").TemplateError;
+    max_limit_not_finite: (limit: number) => import("@rcompat/error").TemplateError;
+    extend_key_collision: (key: string) => import("@rcompat/error").TemplateError;
+    union_at_least_two_members: () => import("@rcompat/error").TemplateError;
+};
+export type Code = keyof typeof errors;
+export declare const Code: { [K in Code]: K; };
+export default errors;
+//# sourceMappingURL=schema-errors.d.ts.map

package/lib/private/schema-errors.js

@@ -0,0 +1,17 @@
+import error from "@rcompat/error";
+const t = error.template;
+const errors = error.coded({
+    unique_subtype_not_primitive: (subtype) => t `unique: subtype ${subtype} must be primitive`,
+    min_negative: (limit) => t `min: ${limit} must be positive`,
+    max_negative: (limit) => t `max: ${limit} must be positive`,
+    length_not_finite: (from, to) => t `length: ${from} and ${to} must be finite numbers`,
+    length_not_positive: (from, to) => t `length: ${from} and ${to} must be positive`,
+    length_from_exceeds_to: (from, to) => t `length: ${from} must be lower than ${to}`,
+    min_limit_not_finite: (limit) => t `min: limit ${limit} must be a finite number`,
+    max_limit_not_finite: (limit) => t `max: limit ${limit} must be a finite number`,
+    extend_key_collision: (key) => t `extend: key ${key} already exists and cannot be overridden`,
+    union_at_least_two_members: () => t `union type must have at least two members`,
+});
+export const Code = Object.fromEntries(Object.keys(errors).map(k => [k, k]));
+export default errors;
+//# sourceMappingURL=schema-errors.js.map

package/lib/private/spec/bigint.d.ts

@@ -1,5 +1,5 @@
 import type BigIntDataType from "#BigIntDataType";
 import type BigIntType from "#BigIntType";
-declare const _default: <T extends BigIntDataType>(i: BigIntType<T>, min: bigint, max: bigint) => void;
+declare const _default: <T extends BigIntDataType>(t: BigIntType<T>, min: bigint, max: bigint) => void;
 export default _default;
 //# sourceMappingURL=bigint.d.ts.map