shelving 1.159.0 → 1.159.2

package/package.json

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

package/schema/ArraySchema.d.ts

@@ -46,7 +46,7 @@ export declare class ArraySchema<T> extends Schema<ImmutableArray<T>> {
     readonly unique: boolean;
     readonly min: number;
     readonly max: number;
-    constructor({ items, one, many, unique, min, max, title, value, ...options }: ArraySchemaOptions<T>);
+    constructor({ items, one, many, title, placeholder, unique, min, max, value, ...options }: ArraySchemaOptions<T>);
     validate(unsafeValue?: unknown): ImmutableArray<T>;
 }
 /** Valid array with specifed items. */

package/schema/ArraySchema.js

@@ -36,8 +36,8 @@ export class ArraySchema extends Schema {
     unique;
     min;
     max;
-    constructor({ items, one = "item", many = `${one}s`, unique = false, min = 0, max = Number.POSITIVE_INFINITY, title = "Items", value = [], ...options }) {
-        super({ title, value, ...options });
+    constructor({ items, one = "item", many = `${one}s`, title = "Items", placeholder = `No ${many}`, unique = false, min = 0, max = Number.POSITIVE_INFINITY, value = [], ...options }) {
+        super({ title, placeholder, value, ...options });
         this.one = one;
         this.many = many;
         this.items = items;
@@ -51,9 +51,9 @@ export class ArraySchema extends Schema {
         const validArray = validateArray(unsafeValue, this.items);
         const uniqueArray = this.unique ? getUniqueArray(validArray) : validArray;
         if (uniqueArray.length < this.min)
-            throw new ValueFeedback(uniqueArray.length ? `Minimum ${this.min} items` : "Required", uniqueArray);
+            throw new ValueFeedback(uniqueArray.length ? `Minimum ${this.min} ${this.many}` : "Required", uniqueArray);
         if (uniqueArray.length > this.max)
-            throw new ValueFeedback(`Maximum ${this.max} items`, uniqueArray);
+            throw new ValueFeedback(`Maximum ${this.max} ${this.many}`, uniqueArray);
         return uniqueArray;
     }
 }

package/schema/ChoiceSchema.d.ts

@@ -14,15 +14,15 @@ export declare function isOption<K extends string>(options: ChoiceOptions<K>, op
 /** 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>;
+    readonly options: ChoiceOptions<K>;
     /** Default option for the value. */
-    value?: K;
+    readonly value?: K;
 }
 /** Choose from an allowed set of values. */
 export declare class ChoiceSchema<K extends string> extends Schema<K> implements Iterable<ChoiceOption<K>> {
     readonly value: K;
     readonly options: ChoiceOptions<K>;
-    constructor({ options, value, ...rest }: ChoiceSchemaOptions<K>);
+    constructor({ options, placeholder, value, ...rest }: ChoiceSchemaOptions<K>);
     validate(unsafeValue?: unknown): K;
     [Symbol.iterator](): Iterator<ChoiceOption<K>>;
     keys(): ImmutableArray<K>;

package/schema/ChoiceSchema.js

@@ -20,8 +20,8 @@ export function isOption(options, option) {
 /** Choose from an allowed set of values. */
 export class ChoiceSchema extends Schema {
     options;
-    constructor({ options, value = requireFirst(isArray(options) ? options : getKeys(options)), ...rest }) {
-        super({ value, ...rest });
+    constructor({ options, placeholder = "Empty", value = requireFirst(isArray(options) ? options : getKeys(options)), ...rest }) {
+        super({ value, placeholder, ...rest });
         this.options = options;
     }
     validate(unsafeValue = this.value) {

package/schema/DictionarySchema.d.ts

@@ -18,7 +18,7 @@ export declare class DictionarySchema<T> extends Schema<ImmutableDictionary<T>>
     readonly items: Schema<T>;
     readonly min: number;
     readonly max: number;
-    constructor({ items, one, many, min, max, title, value, ...options }: DictionarySchemaOptions<T>);
+    constructor({ items, one, many, placeholder, min, max, title, value, ...options }: DictionarySchemaOptions<T>);
     validate(unsafeValue?: unknown): ImmutableDictionary<T>;
 }
 /** Valid dictionary object with specifed items. */

package/schema/DictionarySchema.js

@@ -9,8 +9,8 @@ export class DictionarySchema extends Schema {
     items;
     min;
     max;
-    constructor({ items, one = "item", many = "items", min = 0, max = Number.POSITIVE_INFINITY, title = "Items", value = {}, ...options }) {
-        super({ title, value, ...options });
+    constructor({ items, one = "item", many = `${one}s`, placeholder = `No ${many}`, min = 0, max = Number.POSITIVE_INFINITY, title = "Items", value = {}, ...options }) {
+        super({ title, placeholder, value, ...options });
         this.one = one;
         this.many = many;
         this.items = items;
@@ -23,9 +23,9 @@ export class DictionarySchema extends Schema {
         const validDictionary = validateDictionary(unsafeValue, this.items);
         const length = Object.keys(validDictionary).length;
         if (length < this.min)
-            throw new ValueFeedback(length ? `Minimum ${this.min} items` : "Required", validDictionary);
+            throw new ValueFeedback(length ? `Minimum ${this.min} ${this.many}` : "Required", validDictionary);
         if (length > this.max)
-            throw new ValueFeedback(`Maximum ${this.max} items`, validDictionary);
+            throw new ValueFeedback(`Maximum ${this.max} ${this.many}`, validDictionary);
         return validDictionary;
     }
 }