shelving 1.149.1 → 1.150.0

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.149.1",
+	"version": "1.150.0",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",

package/schema/ChoiceSchema.d.ts

@@ -0,0 +1,19 @@
+import type { SchemaOptions } from "./Schema.js";
+import { Schema } from "./Schema.js";
+export type ChoiceOptions<K extends string> = {
+    readonly [KK in K]: unknown;
+};
+/** Allowed options for `ChoiceSchema` */
+export interface ChoiceSchemaOptions<K extends string> extends Omit<SchemaOptions, "value"> {
+    /** Specify correct options using a dictionary of entries. */
+    options: ChoiceOptions<K>;
+}
+/** Choose from an allowed set of values. */
+export declare class ChoiceSchema<K extends string> extends Schema<K> {
+    readonly value: string;
+    readonly options: ChoiceOptions<K>;
+    constructor({ options, ...rest }: ChoiceSchemaOptions<K>);
+    validate(unsafeValue?: unknown): K;
+}
+/** Choose from an allowed set of values. */
+export declare function CHOICE<K extends string>(options: ChoiceOptions<K>): ChoiceSchema<K>;

package/schema/ChoiceSchema.js

@@ -0,0 +1,21 @@
+import { ValueFeedback } from "../feedback/Feedback.js";
+import { requireFirst } from "../util/array.js";
+import { getKeys, isProp } from "../util/object.js";
+import { Schema } from "./Schema.js";
+/** Choose from an allowed set of values. */
+export class ChoiceSchema extends Schema {
+    options;
+    constructor({ options, ...rest }) {
+        super({ value: requireFirst(getKeys(options)), ...rest });
+        this.options = options;
+    }
+    validate(unsafeValue = this.value) {
+        if (typeof unsafeValue === "string" && isProp(this.options, unsafeValue))
+            return unsafeValue;
+        throw new ValueFeedback("Unknown value", unsafeValue);
+    }
+}
+/** Choose from an allowed set of values. */
+export function CHOICE(options) {
+    return new ChoiceSchema({ options });
+}

package/schema/index.d.ts

@@ -3,9 +3,9 @@ export * from "./ThroughSchema.js";
 export * from "./NullableSchema.js";
 export * from "./OptionalSchema.js";
 export * from "./RequiredSchema.js";
-export * from "./AllowSchema.js";
 export * from "./ArraySchema.js";
 export * from "./BooleanSchema.js";
+export * from "./ChoiceSchema.js";
 export * from "./ColorSchema.js";
 export * from "./DataSchema.js";
 export * from "./DateSchema.js";

package/schema/index.js

@@ -5,9 +5,9 @@ export * from "./NullableSchema.js";
 export * from "./OptionalSchema.js";
 export * from "./RequiredSchema.js";
 // Field schemas.
-export * from "./AllowSchema.js";
 export * from "./ArraySchema.js";
 export * from "./BooleanSchema.js";
+export * from "./ChoiceSchema.js";
 export * from "./ColorSchema.js";
 export * from "./DataSchema.js";
 export * from "./DateSchema.js";

package/test/basics.js

@@ -1,13 +1,13 @@
-import { ALLOW_STRING } from "../schema/AllowSchema.js";
 import { ARRAY } from "../schema/ArraySchema.js";
 import { BOOLEAN } from "../schema/BooleanSchema.js";
+import { CHOICE } from "../schema/ChoiceSchema.js";
 import { DATA } from "../schema/DataSchema.js";
 import { NUMBER } from "../schema/NumberSchema.js";
 import { STRING } from "../schema/StringSchema.js";
 export const BASIC_SCHEMA = DATA({
     str: STRING,
     num: NUMBER,
-    group: ALLOW_STRING({ a: "A", b: "B", c: "C" }),
+    group: CHOICE({ a: "A", b: "B", c: "C" }),
     tags: ARRAY(STRING),
     odd: BOOLEAN,
     even: BOOLEAN,

package/util/validate.js

@@ -14,8 +14,10 @@ export function getValid(value, validator, ErrorConstructor = ValueError, caller
         return validator.validate(value);
     }
     catch (thrown) {
-        if (thrown instanceof Feedback)
-            throw new ErrorConstructor(thrown.message, { received: value, cause: thrown, caller });
+        if (thrown instanceof Feedback) {
+            const { message, ...rest } = thrown;
+            throw new ErrorConstructor(message, { ...rest, cause: thrown, caller });
+        }
         throw thrown;
     }
 }

package/schema/AllowSchema.d.ts

@@ -1,32 +0,0 @@
-import type { Entry } from "../util/entry.js";
-import type { ImmutableMap, PossibleMap, PossibleStringMap } from "../util/map.js";
-import type { SchemaOptions } from "./Schema.js";
-import { Schema } from "./Schema.js";
-/** Allowed options for `AllowSchama` */
-export interface AllowSchemaOptions<K, T> extends Omit<SchemaOptions, "value"> {
-    /** Specify correct options using a `Map` or iterable set of entries. */
-    allow: PossibleMap<K, T>;
-}
-/** Define a valid value from an allowed set of values. */
-export declare class AllowSchema<K, T> extends Schema<K> implements Iterable<Entry<K, T>> {
-    readonly value: K;
-    readonly allow: ImmutableMap<K, T>;
-    constructor(options: AllowSchemaOptions<K, T>);
-    validate(unsafeValue?: unknown): K;
-    /** Iterate over the the allowed options in `[key, value]` format. */
-    [Symbol.iterator](): Iterator<Entry<K, T>>;
-}
-/** Allowed options for `AllowStringSchama` */
-export type AllowStringSchemaOptions<K extends string, T> = Omit<SchemaOptions, "value"> & {
-    /** Specify correct options using a `Map`, iterable set of entries, or an object with string keys. */
-    allow: PossibleStringMap<K, T>;
-};
-/** Define a valid string value from an allowed set of string values. */
-export declare class AllowStringSchema<K extends string, T> extends AllowSchema<K, T> {
-    constructor({ allow, ...options }: AllowStringSchemaOptions<K, T>);
-    validator(unsafeValue?: unknown): K;
-}
-/** Valid value from an allowed set of values. */
-export declare function ALLOW<K, T>(allow: PossibleMap<K, T>): AllowSchema<K, T>;
-/** Valid string from an allowed set of values. */
-export declare function ALLOW_STRING<K extends string, T>(allow: PossibleStringMap<K, T>): AllowSchema<K, T>;

package/schema/AllowSchema.js

@@ -1,41 +0,0 @@
-import { ValueFeedback } from "../feedback/Feedback.js";
-import { requireFirst } from "../util/array.js";
-import { formatValue } from "../util/format.js";
-import { getMap, isMapItem } from "../util/map.js";
-import { Schema } from "./Schema.js";
-/** Define a valid value from an allowed set of values. */
-export class AllowSchema extends Schema {
-    allow;
-    constructor(options) {
-        const allow = getMap(options.allow);
-        const value = requireFirst(allow.keys());
-        super({ value, ...options });
-        this.allow = allow;
-    }
-    validate(unsafeValue = this.value) {
-        if (isMapItem(this.allow, unsafeValue))
-            return unsafeValue;
-        throw new ValueFeedback("Unknown value", unsafeValue);
-    }
-    /** Iterate over the the allowed options in `[key, value]` format. */
-    [Symbol.iterator]() {
-        return this.allow[Symbol.iterator]();
-    }
-}
-/** Define a valid string value from an allowed set of string values. */
-export class AllowStringSchema extends AllowSchema {
-    constructor({ allow, ...options }) {
-        super({ allow: getMap(allow), ...options });
-    }
-    validator(unsafeValue = this.value) {
-        return super.validate(formatValue(unsafeValue));
-    }
-}
-/** Valid value from an allowed set of values. */
-export function ALLOW(allow) {
-    return new AllowSchema({ allow });
-}
-/** Valid string from an allowed set of values. */
-export function ALLOW_STRING(allow) {
-    return new AllowStringSchema({ allow });
-}