shelving 1.187.0 → 1.187.1

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "shelving",
-	"version": "1.187.0",
+	"version": "1.187.1",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"repository": {
 		"type": "git",

package/schema/ChoiceSchema.d.ts

@@ -3,33 +3,34 @@ import type { SchemaOptions } from "./Schema.js";
 import { Schema } from "./Schema.js";
 /**
  * Set of options for a `ChoiceSchema` can be either:
- * - Array of string options in `[key]` format (`key` will be used as the `title` too).
  * - Dictionary of string options in `{ key: title }` format.
  */
-export type ChoiceOptions<K extends string> = ImmutableArray<K> | {
+export type ChoiceOptions<K extends string> = {
     readonly [KK in K]: string;
 };
+/**
+ * Things that can be converted to a choice options dictionary.
+ * - Array of string options in `[key]` format (`key` will be used as the `title` too).
+ */
+export type PossibleChoiceOptions<K extends string> = ImmutableArray<K> | ChoiceOptions<K>;
 /** A single tuple for a choice option in `[key, title]` format. */
 export type ChoiceOption<K extends string> = readonly [title: K, title: string];
-/** Is an unknown string a choice option */
-export declare function isChoiceOption<K extends string>(options: ChoiceOptions<K>, option: string): option is K;
+/** Get a `ChoiceOptions` object for a set of `PossibleChoiceOptions`. */
+export declare function getChoiceOptions<K extends string>(options: PossibleChoiceOptions<K>): ChoiceOptions<K>;
 /** Allowed options for `ChoiceSchema` */
 export interface ChoiceSchemaOptions<K extends string> extends Omit<SchemaOptions, "value"> {
     /** Specify correct options using a dictionary of entries. */
-    readonly options: ChoiceOptions<K>;
+    readonly options: PossibleChoiceOptions<K>;
     /** Default option for the value. */
     readonly value?: K;
 }
 /** Choose from an allowed set of values. */
-export declare class ChoiceSchema<K extends string> extends Schema<K> implements Iterable<ChoiceOption<K>> {
+export declare class ChoiceSchema<K extends string> extends Schema<K> {
     readonly value: K | undefined;
     readonly options: ChoiceOptions<K>;
     constructor({ one, title, placeholder, options, value, ...rest }: ChoiceSchemaOptions<K>);
     validate(unsafeValue?: unknown): K;
     format(value: K): string;
-    keys(): ImmutableArray<K>;
-    entries(): ImmutableArray<ChoiceOption<K>>;
-    [Symbol.iterator](): Iterator<ChoiceOption<K>>;
 }
 /** Choose from an allowed set of values. */
-export declare function CHOICE<K extends string>(options: ChoiceOptions<K> | ImmutableArray<K>): ChoiceSchema<K>;
+export declare function CHOICE<K extends string>(options: PossibleChoiceOptions<K> | ImmutableArray<K>): ChoiceSchema<K>;

package/schema/ChoiceSchema.js

@@ -1,46 +1,27 @@
-import { isArray, isArrayItem } from "../util/array.js";
-import { getKeys, getProps, isProp } from "../util/object.js";
+import { isArray } from "../util/array.js";
+import { isProp } from "../util/object.js";
 import { Schema } from "./Schema.js";
-/** Is an unknown string a choice option */
-export function isChoiceOption(options, option) {
-    return isArray(options) ? isArrayItem(options, option) : isProp(options, option);
+/** Get a `ChoiceOptions` object for a set of `PossibleChoiceOptions`. */
+export function getChoiceOptions(options) {
+    return isArray(options) ? Object.fromEntries(options.map(_getChoiceOption)) : options;
 }
-/** Get a dictionary from a plain array of options. */
-function* _yieldArrayChoiceOptions(options) {
-    for (const k of options)
-        yield [k, k];
+function _getChoiceOption(k) {
+    return [k, k];
 }
 /** Choose from an allowed set of values. */
 export class ChoiceSchema extends Schema {
     options;
     constructor({ one = "choice", title = "Choice", placeholder = `No ${one}`, options, value, ...rest }) {
         super({ one, title, value, placeholder, ...rest });
-        this.options = options;
+        this.options = getChoiceOptions(options);
     }
     validate(unsafeValue = this.value) {
-        if (typeof unsafeValue === "string" && isChoiceOption(this.options, unsafeValue))
+        if (typeof unsafeValue === "string" && isProp(this.options, unsafeValue))
             return unsafeValue;
         throw unsafeValue ? `Unknown ${this.one}` : "Required";
     }
     format(value) {
-        return isArray(this.options) ? value : this.options[value];
-    }
-    // Get the current list of keys for this choice.
-    keys() {
-        return isArray(this.options) ? this.options : getKeys(this.options);
-    }
-    // Get the current list of entries for this choice.
-    entries() {
-        return isArray(this.options) ? Array.from(_yieldArrayChoiceOptions(this.options)) : getProps(this.options);
-    }
-    // Implement iterable.
-    *[Symbol.iterator]() {
-        if (isArray(this.options)) {
-            yield* _yieldArrayChoiceOptions(this.options);
-        }
-        else {
-            yield* getProps(this.options);
-        }
+        return this.options[value];
     }
 }
 /** Choose from an allowed set of values. */