shelving 1.155.0 → 1.157.0

package/package.json

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

package/schema/ChoiceSchema.d.ts

@@ -1,19 +1,32 @@
+import { type ImmutableArray } from "../util/array.js";
 import type { SchemaOptions } from "./Schema.js";
 import { Schema } from "./Schema.js";
-export type ChoiceOptions<K extends string> = {
+export type ChoiceOptions<K extends string> = ImmutableArray<K> | {
     readonly [KK in K]: unknown;
 };
+export type ChoiceOption<K extends string> = readonly [K, unknown];
+/** Get the options for a choice field as an array. */
+export declare function getChoiceEntries<K extends string>(options: ChoiceOptions<K>): ImmutableArray<ChoiceOption<K>>;
+/** Get the keys for a choice field as an array. */
+export declare function getChoiceKeys<K extends string>(options: ChoiceOptions<K>): ImmutableArray<K>;
+/** Get the options for a choice field as an array. */
+export declare function isOption<K extends string>(options: ChoiceOptions<K>, option: string): option is K;
 /** 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>;
+    /** Default option for the value. */
+    value?: K;
 }
 /** Choose from an allowed set of values. */
-export declare class ChoiceSchema<K extends string> extends Schema<K> {
-    readonly value: string;
+export declare class ChoiceSchema<K extends string> extends Schema<K> implements Iterable<ChoiceOption<K>> {
+    readonly value: K;
     readonly options: ChoiceOptions<K>;
-    constructor({ options, ...rest }: ChoiceSchemaOptions<K>);
+    constructor({ options, value, ...rest }: ChoiceSchemaOptions<K>);
     validate(unsafeValue?: unknown): K;
+    [Symbol.iterator](): Iterator<ChoiceOption<K>>;
+    keys(): ImmutableArray<K>;
+    entries(): ImmutableArray<ChoiceOption<K>>;
 }
 /** Choose from an allowed set of values. */
 export declare function CHOICE<K extends string>(options: ChoiceOptions<K>): ChoiceSchema<K>;

package/schema/ChoiceSchema.js

@@ -1,19 +1,46 @@
 import { ValueFeedback } from "../feedback/Feedback.js";
-import { requireFirst } from "../util/array.js";
-import { getKeys, isProp } from "../util/object.js";
+import { isArray, requireFirst } from "../util/array.js";
+import { getKeys, getProps, isProp } from "../util/object.js";
 import { Schema } from "./Schema.js";
+/** Get the options for a choice field as an array. */
+export function getChoiceEntries(options) {
+    return isArray(options) ? options.map(_makeKeyEntry) : getProps(options);
+}
+function _makeKeyEntry(k) {
+    return [k, k];
+}
+/** Get the keys for a choice field as an array. */
+export function getChoiceKeys(options) {
+    return isArray(options) ? options : getKeys(options);
+}
+/** Get the options for a choice field as an array. */
+export function isOption(options, option) {
+    return isArray(options) ? options.includes(option) : isProp(options, option);
+}
 /** Choose from an allowed set of values. */
 export class ChoiceSchema extends Schema {
     options;
-    constructor({ options, ...rest }) {
-        super({ value: requireFirst(getKeys(options)), ...rest });
+    constructor({ options, value = requireFirst(isArray(options) ? options : getKeys(options)), ...rest }) {
+        super({ value, ...rest });
         this.options = options;
     }
     validate(unsafeValue = this.value) {
-        if (typeof unsafeValue === "string" && isProp(this.options, unsafeValue))
+        if (typeof unsafeValue === "string" && isOption(this.options, unsafeValue))
             return unsafeValue;
         throw new ValueFeedback("Unknown value", unsafeValue);
     }
+    // Implement iterable.
+    *[Symbol.iterator]() {
+        yield* getChoiceEntries(this.options);
+    }
+    // Get the current list of keys for this choice.
+    keys() {
+        return getChoiceKeys(this.options);
+    }
+    // Get the current list of entries for this choice.
+    entries() {
+        return getChoiceEntries(this.options);
+    }
 }
 /** Choose from an allowed set of values. */
 export function CHOICE(options) {