shelving 1.126.1 → 1.126.3

package/feedback/Feedback.d.ts

@@ -9,8 +9,11 @@
 export declare class Feedback {
     /** String feedback message that is safe to show to a user. */
     readonly message: string;
-    /** Nested details providing deeper feedback. */
-    readonly value: unknown;
-    constructor(feedback: string, value?: unknown);
+    constructor(message: string);
     toString(): string;
 }
+/** Feedback with a known and typed `.value` field. */
+export declare class ValueFeedback<T> extends Feedback {
+    readonly value: T;
+    constructor(message: string, value: T);
+}

package/feedback/Feedback.js

@@ -9,13 +9,18 @@
 export class Feedback {
     /** String feedback message that is safe to show to a user. */
     message;
-    /** Nested details providing deeper feedback. */
-    value;
-    constructor(feedback, value) {
-        this.message = feedback;
-        this.value = value;
+    constructor(message) {
+        this.message = message;
     }
     toString() {
         return this.message;
     }
 }
+/** Feedback with a known and typed `.value` field. */
+export class ValueFeedback extends Feedback {
+    value;
+    constructor(message, value) {
+        super(message);
+        this.value = value;
+    }
+}

package/feedback/Feedbacks.d.ts

@@ -1,10 +1,13 @@
 import type { ImmutableDictionary } from "../util/dictionary.js";
 import { Feedback } from "./Feedback.js";
-/** Feedback with a list of sub-feedbacks. */
+/** Feedback with a set of named messages. */
 export declare class Feedbacks extends Feedback {
-    /** List of sub-feedbacks. */
-    readonly feedbacks: ImmutableDictionary<Feedback>;
-    /** List of sub-messages. */
-    get messages(): ImmutableDictionary<string>;
-    constructor(feedbacks: ImmutableDictionary<Feedback>, value?: unknown);
+    /** List of named messages. */
+    readonly messages: ImmutableDictionary<string>;
+    constructor(messages: ImmutableDictionary<string>);
+}
+/** Feedbacks with a known and typed `.value` field. */
+export declare class ValueFeedbacks<T> extends Feedbacks {
+    readonly value: T;
+    constructor(messages: ImmutableDictionary<string>, value: T);
 }

package/feedback/Feedbacks.js

@@ -1,17 +1,18 @@
-import { getProp } from "../util/object.js";
-import { mapDictionary } from "../util/transform.js";
 import { Feedback } from "./Feedback.js";
-/** Feedback with a list of sub-feedbacks. */
+/** Feedback with a set of named messages. */
 export class Feedbacks extends Feedback {
-    /** List of sub-feedbacks. */
-    feedbacks;
-    /** List of sub-messages. */
-    get messages() {
-        return mapDictionary(this.feedbacks, getProp, "message");
+    /** List of named messages. */
+    messages;
+    constructor(messages) {
+        super("Multiple errors");
+        this.messages = messages;
     }
-    constructor(feedbacks, value) {
-        const first = Object.values(feedbacks)[0];
-        super(first?.message || "Unknown error", value);
-        this.feedbacks = feedbacks;
+}
+/** Feedbacks with a known and typed `.value` field. */
+export class ValueFeedbacks extends Feedbacks {
+    value;
+    constructor(messages, value) {
+        super(messages);
+        this.value = value;
     }
 }

package/feedback/index.d.ts

@@ -1,3 +1,2 @@
 export * from "./Feedback.js";
 export * from "./Feedbacks.js";
-export * from "./hydrations.js";

package/feedback/index.js

@@ -1,3 +1,2 @@
 export * from "./Feedback.js";
 export * from "./Feedbacks.js";
-export * from "./hydrations.js";

package/package.json

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

package/schema/AllowSchema.js

@@ -1,4 +1,4 @@
-import { Feedback } from "../feedback/Feedback.js";
+import { ValueFeedback } from "../feedback/Feedback.js";
 import { getFirstItem } from "../util/array.js";
 import { getMap, isMapItem } from "../util/map.js";
 import { getString } from "../util/string.js";
@@ -15,7 +15,7 @@ export class AllowSchema extends Schema {
     validate(unsafeValue = this.value) {
         if (isMapItem(this.allow, unsafeValue))
             return unsafeValue;
-        throw new Feedback("Unknown value", unsafeValue);
+        throw new ValueFeedback("Unknown value", unsafeValue);
     }
     /** Iterate over the the allowed options in `[key, value]` format. */
     [Symbol.iterator]() {

package/schema/ArraySchema.js

@@ -1,4 +1,4 @@
-import { Feedback } from "../feedback/Feedback.js";
+import { ValueFeedback } from "../feedback/Feedback.js";
 import { getUniqueArray, isArray } from "../util/array.js";
 import { validateArray } from "../util/validate.js";
 import { Schema } from "./Schema.js";
@@ -43,13 +43,13 @@ export class ArraySchema extends Schema {
     }
     validate(unsafeValue = this.value) {
         if (!isArray(unsafeValue))
-            throw new Feedback("Must be array", unsafeValue);
+            throw new ValueFeedback("Must be array", unsafeValue);
         const validArray = validateArray(unsafeValue, this.items);
         const uniqueArray = this.unique ? getUniqueArray(validArray) : validArray;
         if (uniqueArray.length < this.min)
-            throw new Feedback(uniqueArray.length ? `Minimum ${this.min} items` : "Required", uniqueArray);
+            throw new ValueFeedback(uniqueArray.length ? `Minimum ${this.min} items` : "Required", uniqueArray);
         if (uniqueArray.length > this.max)
-            throw new Feedback(`Maximum ${this.max} items`, uniqueArray);
+            throw new ValueFeedback(`Maximum ${this.max} items`, uniqueArray);
         return uniqueArray;
     }
 }

package/schema/DataSchema.js

@@ -1,4 +1,4 @@
-import { Feedback } from "../feedback/Feedback.js";
+import { ValueFeedback } from "../feedback/Feedback.js";
 import { isData } from "../util/data.js";
 import { validateData } from "../util/validate.js";
 import { OPTIONAL } from "./OptionalSchema.js";
@@ -12,7 +12,7 @@ export class DataSchema extends Schema {
     }
     validate(unsafeValue = this.value) {
         if (!isData(unsafeValue))
-            throw new Feedback("Must be object", unsafeValue);
+            throw new ValueFeedback("Must be object", unsafeValue);
         return validateData(unsafeValue, this.props);
     }
 }

package/schema/DateSchema.js

@@ -1,4 +1,4 @@
-import { Feedback } from "../feedback/Feedback.js";
+import { ValueFeedback } from "../feedback/Feedback.js";
 import { formatDate, getOptionalDate, getYMD } from "../util/date.js";
 import { OPTIONAL } from "./OptionalSchema.js";
 import { Schema } from "./Schema.js";
@@ -14,11 +14,11 @@ export class DateSchema extends Schema {
     validate(unsafeValue = this.value) {
         const optionalDate = getOptionalDate(unsafeValue);
         if (!optionalDate)
-            throw new Feedback(unsafeValue ? "Invalid date" : "Required", unsafeValue);
+            throw new ValueFeedback(unsafeValue ? "Invalid date" : "Required", unsafeValue);
         if (this.min && optionalDate < this.min)
-            throw new Feedback(`Minimum ${formatDate(this.min)}`, optionalDate);
+            throw new ValueFeedback(`Minimum ${formatDate(this.min)}`, optionalDate);
         if (this.max && optionalDate > this.max)
-            throw new Feedback(`Maximum ${formatDate(this.max)}`, optionalDate);
+            throw new ValueFeedback(`Maximum ${formatDate(this.max)}`, optionalDate);
         return getYMD(optionalDate);
     }
 }

package/schema/DictionarySchema.js

@@ -1,4 +1,4 @@
-import { Feedback } from "../feedback/Feedback.js";
+import { ValueFeedback } from "../feedback/Feedback.js";
 import { isDictionary } from "../util/dictionary.js";
 import { validateDictionary } from "../util/validate.js";
 import { Schema } from "./Schema.js";
@@ -15,13 +15,13 @@ export class DictionarySchema extends Schema {
     }
     validate(unsafeValue = this.value) {
         if (!isDictionary(unsafeValue))
-            throw new Feedback("Must be object", unsafeValue);
+            throw new ValueFeedback("Must be object", unsafeValue);
         const validDictionary = validateDictionary(unsafeValue, this.items);
         const length = Object.keys(validDictionary).length;
         if (length < this.min)
-            throw new Feedback(length ? `Minimum ${this.min} items` : "Required", validDictionary);
+            throw new ValueFeedback(length ? `Minimum ${this.min} items` : "Required", validDictionary);
         if (length > this.max)
-            throw new Feedback(`Maximum ${this.max} items`, validDictionary);
+            throw new ValueFeedback(`Maximum ${this.max} items`, validDictionary);
         return validDictionary;
     }
 }

package/schema/EntitySchema.js

@@ -1,4 +1,4 @@
-import { Feedback } from "../feedback/Feedback.js";
+import { ValueFeedback } from "../feedback/Feedback.js";
 import { isArrayItem } from "../util/array.js";
 import { splitOptionalEntity } from "../util/entity.js";
 import { OPTIONAL } from "./OptionalSchema.js";
@@ -14,9 +14,9 @@ export class EntitySchema extends StringSchema {
         const entity = super.validate(unsafeValue);
         const [type] = splitOptionalEntity(entity);
         if (!type)
-            throw new Feedback("Must be entity", unsafeValue);
+            throw new ValueFeedback("Must be entity", unsafeValue);
         if (this.types && !isArrayItem(this.types, type))
-            throw new Feedback("Invalid entity type", type);
+            throw new ValueFeedback("Invalid entity type", type);
         return entity;
     }
 }

package/schema/FileSchema.js

@@ -1,4 +1,4 @@
-import { Feedback } from "../feedback/Feedback.js";
+import { ValueFeedback } from "../feedback/Feedback.js";
 import { getOptionalFileExtension } from "../util/file.js";
 import { isProp } from "../util/object.js";
 import { OPTIONAL } from "./OptionalSchema.js";
@@ -14,9 +14,9 @@ export class FileSchema extends StringSchema {
         const path = super.validate(unsafeValue);
         const extension = getOptionalFileExtension(path);
         if (!extension)
-            throw new Feedback("Must be file name with extension", unsafeValue);
+            throw new ValueFeedback("Must be file name with extension", unsafeValue);
         if (this.types && !isProp(this.types, extension))
-            throw new Feedback("Invalid file type", extension);
+            throw new ValueFeedback("Invalid file type", extension);
         return path;
     }
 }

package/schema/LinkSchema.js

@@ -1,4 +1,4 @@
-import { Feedback } from "../feedback/Feedback.js";
+import { ValueFeedback } from "../feedback/Feedback.js";
 import { getOptionalLinkURL } from "../util/link.js";
 import { OPTIONAL } from "./OptionalSchema.js";
 import { StringSchema } from "./StringSchema.js";
@@ -30,7 +30,7 @@ export class LinkSchema extends StringSchema {
         const unsafeString = super.validate(unsafeValue);
         const url = getOptionalLinkURL(super.sanitize(unsafeString), this.base, this.schemes, this.hosts);
         if (!url)
-            throw new Feedback(unsafeString ? "Invalid format" : "Required", unsafeString);
+            throw new ValueFeedback(unsafeString ? "Invalid format" : "Required", unsafeString);
         return url.href;
     }
 }

package/schema/NumberSchema.js

@@ -1,4 +1,4 @@
-import { Feedback } from "../feedback/Feedback.js";
+import { ValueFeedback } from "../feedback/Feedback.js";
 import { formatNumber, getOptionalNumber, roundStep } from "../util/number.js";
 import { OPTIONAL } from "./OptionalSchema.js";
 import { Schema } from "./Schema.js";
@@ -16,12 +16,12 @@ export class NumberSchema extends Schema {
     validate(unsafeValue = this.value) {
         const optionalNumber = getOptionalNumber(unsafeValue);
         if (typeof optionalNumber !== "number")
-            throw new Feedback("Must be number", unsafeValue);
+            throw new ValueFeedback("Must be number", unsafeValue);
         const roundedNumber = typeof this.step === "number" ? roundStep(optionalNumber, this.step) : optionalNumber;
         if (roundedNumber > this.max)
-            throw new Feedback(`Maximum ${formatNumber(this.max)}`, roundedNumber);
+            throw new ValueFeedback(`Maximum ${formatNumber(this.max)}`, roundedNumber);
         if (roundedNumber < this.min)
-            throw new Feedback(`Minimum ${formatNumber(this.min)}`, roundedNumber);
+            throw new ValueFeedback(`Minimum ${formatNumber(this.min)}`, roundedNumber);
         return roundedNumber;
     }
 }

package/schema/RequiredSchema.js

@@ -1,11 +1,11 @@
-import { Feedback } from "../feedback/Feedback.js";
+import { ValueFeedback } from "../feedback/Feedback.js";
 import { ThroughSchema } from "./ThroughSchema.js";
 /** Validate a value of a specifed type, but throw `Feedback` if the validated value is falsy. */
 export class RequiredSchema extends ThroughSchema {
     validate(unsafeValue) {
         const safeValue = super.validate(unsafeValue);
         if (!safeValue)
-            throw new Feedback("Required", safeValue);
+            throw new ValueFeedback("Required", safeValue);
         return safeValue;
     }
 }

package/schema/StringSchema.js

@@ -1,4 +1,4 @@
-import { Feedback } from "../feedback/Feedback.js";
+import { ValueFeedback } from "../feedback/Feedback.js";
 import { sanitizeLines, sanitizeString } from "../util/string.js";
 import { OPTIONAL } from "./OptionalSchema.js";
 import { Schema } from "./Schema.js";
@@ -41,14 +41,14 @@ export class StringSchema extends Schema {
     validate(unsafeValue = this.value) {
         const possibleString = typeof unsafeValue === "number" ? unsafeValue.toString() : unsafeValue;
         if (typeof possibleString !== "string")
-            throw new Feedback("Must be string", unsafeValue);
+            throw new ValueFeedback("Must be string", unsafeValue);
         const saneString = this.sanitize(possibleString);
         if (saneString.length < this.min)
-            throw new Feedback(saneString ? `Minimum ${this.min} characters` : "Required", saneString);
+            throw new ValueFeedback(saneString ? `Minimum ${this.min} characters` : "Required", saneString);
         if (saneString.length > this.max)
-            throw new Feedback(`Maximum ${this.max} characters`, saneString);
+            throw new ValueFeedback(`Maximum ${this.max} characters`, saneString);
         if (this.match && !this.match.test(saneString))
-            throw new Feedback(saneString ? "Invalid format" : "Required", saneString);
+            throw new ValueFeedback(saneString ? "Invalid format" : "Required", saneString);
         return saneString;
     }
     /**

package/schema/TimeSchema.js

@@ -1,4 +1,4 @@
-import { Feedback } from "../feedback/Feedback.js";
+import { ValueFeedback } from "../feedback/Feedback.js";
 import { roundStep } from "../util/number.js";
 import { Time, getOptionalTime } from "../util/time.js";
 import { OPTIONAL } from "./OptionalSchema.js";
@@ -21,12 +21,12 @@ export class TimeSchema extends Schema {
     validate(unsafeValue = this.value) {
         const optionalTime = getOptionalTime(unsafeValue);
         if (!optionalTime)
-            throw new Feedback(unsafeValue ? "Invalid time" : "Required", unsafeValue);
+            throw new ValueFeedback(unsafeValue ? "Invalid time" : "Required", unsafeValue);
         const roundedTime = typeof this.step === "number" ? new Time(roundStep(optionalTime.time, this.step)) : optionalTime;
         if (this.max && roundedTime > this.max)
-            throw new Feedback(`Maximum ${this.max.format()}`, roundedTime);
+            throw new ValueFeedback(`Maximum ${this.max.format()}`, roundedTime);
         if (this.min && roundedTime < this.min)
-            throw new Feedback(`Minimum ${this.min.format()}`, roundedTime);
+            throw new ValueFeedback(`Minimum ${this.min.format()}`, roundedTime);
         return roundedTime.long;
     }
 }

package/util/validate.js

@@ -1,6 +1,6 @@
 import { ValueError } from "../error/ValueError.js";
 import { Feedback } from "../feedback/Feedback.js";
-import { Feedbacks } from "../feedback/Feedbacks.js";
+import { ValueFeedbacks } from "../feedback/Feedbacks.js";
 import { getLastItem, isArray } from "./array.js";
 import { getDataProps } from "./data.js";
 import { getDictionaryItems } from "./dictionary.js";
@@ -31,7 +31,7 @@ export function assertValid(unsafeValue, validator) {
 export function* validateItems(unsafeItems, validator) {
     let index = 0;
     let valid = true;
-    const feedbacks = {};
+    const messages = {};
     for (const unsafeItem of unsafeItems) {
         try {
             yield validator.validate(unsafeItem);
@@ -39,13 +39,13 @@ export function* validateItems(unsafeItems, validator) {
         catch (thrown) {
             if (!(thrown instanceof Feedback))
                 throw thrown;
-            feedbacks[index] = thrown;
+            messages[index] = thrown.message;
             valid = false;
         }
         index++;
     }
     if (!valid)
-        throw new Feedbacks(feedbacks, unsafeItems);
+        throw new ValueFeedbacks(messages, unsafeItems);
 }
 /**
  * Validate an array of items.
@@ -59,7 +59,7 @@ export function validateArray(unsafeArray, validator) {
     let valid = true;
     let changed = true;
     const safeArray = [];
-    const feedbacks = {};
+    const messages = {};
     for (const unsafeItem of unsafeArray) {
         try {
             const safeItem = validator.validate(unsafeItem);
@@ -70,13 +70,13 @@ export function validateArray(unsafeArray, validator) {
         catch (thrown) {
             if (!(thrown instanceof Feedback))
                 throw thrown;
-            feedbacks[index] = thrown;
+            messages[index] = thrown.message;
             valid = false;
         }
         index++;
     }
     if (!valid)
-        throw new Feedbacks(feedbacks, unsafeArray);
+        throw new ValueFeedbacks(messages, unsafeArray);
     return changed || !isArray(unsafeArray) ? safeArray : unsafeArray;
 }
 /**
@@ -89,7 +89,7 @@ export function validateDictionary(unsafeDictionary, validator) {
     let valid = true;
     let changed = false;
     const safeDictionary = {};
-    const feedbacks = {};
+    const messages = {};
     for (const [key, unsafeValue] of getDictionaryItems(unsafeDictionary)) {
         try {
             const safeValue = validator.validate(unsafeValue);
@@ -100,12 +100,12 @@ export function validateDictionary(unsafeDictionary, validator) {
         catch (thrown) {
             if (!(thrown instanceof Feedback))
                 throw thrown;
-            feedbacks[key] = thrown;
+            messages[key] = thrown.message;
             valid = false;
         }
     }
     if (!valid)
-        throw new Feedbacks(feedbacks, unsafeDictionary);
+        throw new ValueFeedbacks(messages, unsafeDictionary);
     return changed || isIterable(unsafeDictionary) ? safeDictionary : unsafeDictionary;
 }
 /**
@@ -122,7 +122,7 @@ export function validateData(unsafeData, validators) {
     let valid = true;
     let changed = true;
     const safeData = id && typeof unsafeData.id === "string" ? { id: unsafeData.id } : {};
-    const feedbacks = {};
+    const messages = {};
     for (const [key, validator] of getDataProps(validators)) {
         const unsafeValue = unsafeData[key];
         if (unsafeValue === undefined && partial)
@@ -136,12 +136,12 @@ export function validateData(unsafeData, validators) {
         catch (thrown) {
             if (!(thrown instanceof Feedback))
                 throw thrown;
-            feedbacks[key] = thrown;
+            messages[key] = thrown.message;
             valid = false;
         }
     }
     if (!valid)
-        throw new Feedbacks(feedbacks, unsafeData);
+        throw new ValueFeedbacks(messages, unsafeData);
     return changed ? safeData : unsafeData;
 }
 /** Store a list of current contexts. */

package/feedback/hydrations.d.ts

@@ -1,3 +0,0 @@
-import type { Hydrations } from "../util/hydrate.js";
-/** Set of hydrations for all feedback classes. */
-export declare const FEEDBACK_HYDRATIONS: Hydrations;

package/feedback/hydrations.js

@@ -1,7 +0,0 @@
-import { Feedback } from "./Feedback.js";
-import { Feedbacks } from "./Feedbacks.js";
-/** Set of hydrations for all feedback classes. */
-export const FEEDBACK_HYDRATIONS = {
-    Feedback,
-    Feedbacks,
-};