@buildkitchen/validation 0.0.0-stage → 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kwasi A. Mensah
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,52 @@
-# Temporary Holding Version
+# 📦 @buildkitchen/validation
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A library for validating data across serialization/deserialization boundaries.
+
+## Installation
+
+Install the package via your preferred package manager:
+
+```bash
+npm install @buildkitchen/validation
+```
+
+Or using yarn/pnpm:
+
+```bash
+yarn add @buildkitchen/validation
+pnpm add @buildkitchen/validation
+```
+
+## Usage
+
+```typescript
+interface Test extends JSONObject {
+  readonly foo: string;
+  readonly x: number;
+}
+const test = JSON.stringify({ foo: "bar", x: 42 });
+const unvalidated = Unvalidated.createFromJSON<Test>(
+  test,
+  "loaded from helloWorld.txt"
+);
+validateString(unvalidated.get("foo")); // "bar"
+validateNumber(unvalidated.get("x")); // 42
+
+// Typescript won't compile because foo1 is not a member of the validated type.
+// Also paired with a runtime error.
+validateString(unvalidated.get("foo1"));
+```
+
+We wrap unvalidated values with this called and use the validate* functions to check types and get clean errors when there's a mismatch.
+
+## API Reference
+
+[Full documentation on Codeberg](https://codeberg.org/buildkitchen/validation/src/branch/main/docs)
+
+## Contributing
+
+We're not actively soliticing contributions but please let us know of any bugs/issues you find in this code and we'll try to resolve them in a timely manner.
+
+## License
+
+Distributed under the MIT License. See `LICENSE` for more information.

package/index.d.ts

@@ -0,0 +1,164 @@
+/**
+ * {@include README.md}
+ * @packageDocumentation
+ */
+/**
+ * Represent data who's type hasn't been validated yet.
+ *
+ * ```typescript
+ *  interface Test extends JSONObject {
+ *    readonly foo: string;
+ *    readonly x: number;
+ *  }
+ *  const test = JSON.stringify({foo: "bar", x: 42})
+ *  const unvalidated = Unvalidated.createFromJSON<Test>(test, "loaded from helloWorld.txt");
+ *  validateString(unvalidated.get("foo")); // "bar"
+ *  validateNumber(unvalidated.get("x")); // 42
+ *
+ *  // Typescript won't compile because foo1 is not a member of the validated type.
+ *  // Also paired with a runtime error.
+ *  validateString(unvalidated.get("foo1"));
+ * ```
+ *
+ *
+ * @typeParam T - An interface describing the shape the object should have. Used in the typing of {@link Unvalidated.get}
+ * to statically enforce type safety.
+ */
+export declare class Unvalidated<T> {
+    readonly rawValue: unknown;
+    readonly context: ReadonlyArray<string | number>;
+    /** @internal */
+    readonly __typeCheck: T;
+    /**
+     * Creates an instance of UserProfile.
+     *
+     * @param rawValue The unvalidated data. Allows direct access for complex validation cases.
+     * @param context Context used for reporting errors during validation.
+     */
+    private constructor();
+    /**
+     * Create an Unvalidated<T> from an in-memory object.
+     *
+     * Useful when getting data from a source who's schema still needs to be checked i.e. database results etc.
+     *
+     * @typeParam T - An interface describing the shape the object should have.
+     * @param rawValue
+     * @param context
+     * @param relevantValue
+     * @returns
+     */
+    static create<T>(rawValue: T, context: string | number, relevantValue?: Unvalidated<unknown>): Unvalidated<T>;
+    /**
+     * Create an Unvalidated<T> from JSON text.
+     *
+     * Shortcut for creating an Unvalidated<T> from JSON.
+     *
+     * @typeParam T - An interface describing the shape the object should have.
+     * @param json
+     * @param context
+     * @returns
+     */
+    static createFromJSON<T extends JSONValue>(json: string, context: string): Unvalidated<T>;
+    /**
+     * Access a value from an Unvalidated object.
+     *
+     * returns Unvalidated<undefined> of this key does not exist on the object.
+     *
+     * @param key
+     * @returns
+     */
+    get<K extends (T extends undefined ? never : keyof T)>(key: K & (string | number)): Unvalidated<T extends undefined ? undefined : T[K]>;
+    /**
+     * Helper to allow casting parent types to child types.
+     *
+     * Mostly used after type discrimination with {@link validateIsMember}
+     *
+     * @returns
+     */
+    castTo<U extends T>(): Unvalidated<U>;
+    /**
+     * Wrap the Unvalidated's context around an error throw during validation.
+     *
+     * @param cause
+     */
+    throwValidationError(cause: Error): never;
+}
+/**
+ * Validate possibly undefined value with a custom validator
+ *
+ * @param value
+ * @param validator
+ * @returns
+ */
+export declare function validateMaybeUndefined<T, V>(value: Unvalidated<T | undefined>, validator: (value: Unvalidated<T>) => V): V | undefined;
+/**
+ * Validate that the value is a string.
+ *
+ * @param value
+ * @returns
+ */
+export declare function validateString(value: Unvalidated<string>): string;
+/**
+ * Validate that the value is number.
+ * @param value
+ * @returns
+ */
+export declare function validateNumber(value: Unvalidated<number>): number;
+/**
+ * Validate that the value is a BigInt.
+ * @param value
+ * @returns
+ */
+export declare function validateBigInt(value: Unvalidated<bigint>): bigint;
+/**
+ * Validate that the value us a boolean.
+ * @param value
+ * @returns
+ */
+export declare function validateBoolean(value: Unvalidated<boolean>): boolean;
+/**
+ * Validate that the value is an array, using a custom validator for each element.
+ * @param array
+ * @param validator
+ * @returns
+ */
+export declare function validateArray<T, V = T>(array: Unvalidated<ReadonlyArray<T>>, validator: (object: Unvalidated<T>, index: number) => V): Array<V>;
+/**
+ * Shortuct for combining {@link validateArray} with {@link validateString}
+ * @param object
+ * @returns
+ */
+export declare function validateStringArray(object: Unvalidated<ReadonlyArray<string>>): ReadonlyArray<string>;
+/**
+ * Validate a Record with string keys with a custom validator for the values.
+ * @param value
+ * @param validator
+ * @returns
+ */
+export declare function validateObject<T, S>(value: Unvalidated<Record<string, T>>, validator: (unvalidated: Unvalidated<T>, key: string) => S): Record<string, S>;
+/**
+ * Validate that value is a string that is a member of group.
+ *
+ * Useful when relying on type discrimination to help figure out which child type to cast a parent type to.
+ * @param value
+ * @param group
+ * @returns
+ */
+export declare function validateIsMember<S extends string>(value: Unvalidated<S>, group: ReadonlySet<S>): S;
+export type JSONPrimitive = string | number | boolean | null | undefined;
+export type JSONValue = JSONPrimitive | JSONObject | ReadonlyArray<JSONValue>;
+export interface JSONObject {
+    [key: string]: JSONValue | undefined;
+}
+/**
+ * Validate a JSON value.
+ * @param value
+ * @returns
+ */
+export declare function validateJSONValue(value: Unvalidated<JSONValue>): JSONValue;
+/**
+ * Validate a JSON object.
+ * @param jsonObject
+ * @returns
+ */
+export declare function validateJSONObject(jsonObject: Unvalidated<JSONObject>): JSONObject;

package/index.js

@@ -0,0 +1,271 @@
+/**
+ * {@include README.md}
+ * @packageDocumentation
+ */
+/**
+ * Represent data who's type hasn't been validated yet.
+ *
+ * ```typescript
+ *  interface Test extends JSONObject {
+ *    readonly foo: string;
+ *    readonly x: number;
+ *  }
+ *  const test = JSON.stringify({foo: "bar", x: 42})
+ *  const unvalidated = Unvalidated.createFromJSON<Test>(test, "loaded from helloWorld.txt");
+ *  validateString(unvalidated.get("foo")); // "bar"
+ *  validateNumber(unvalidated.get("x")); // 42
+ *
+ *  // Typescript won't compile because foo1 is not a member of the validated type.
+ *  // Also paired with a runtime error.
+ *  validateString(unvalidated.get("foo1"));
+ * ```
+ *
+ *
+ * @typeParam T - An interface describing the shape the object should have. Used in the typing of {@link Unvalidated.get}
+ * to statically enforce type safety.
+ */
+export class Unvalidated {
+    rawValue;
+    context;
+    // This makes sure that each instance of Unvalidated isn't ducktyped to each other
+    /** @internal */
+    __typeCheck;
+    /**
+     * Creates an instance of UserProfile.
+     *
+     * @param rawValue The unvalidated data. Allows direct access for complex validation cases.
+     * @param context Context used for reporting errors during validation.
+     */
+    constructor(rawValue, context) {
+        this.rawValue = rawValue;
+        this.context = context;
+        this.__typeCheck = undefined;
+    }
+    /**
+     * Create an Unvalidated<T> from an in-memory object.
+     *
+     * Useful when getting data from a source who's schema still needs to be checked i.e. database results etc.
+     *
+     * @typeParam T - An interface describing the shape the object should have.
+     * @param rawValue
+     * @param context
+     * @param relevantValue
+     * @returns
+     */
+    static create(rawValue, context, relevantValue) {
+        return new Unvalidated(rawValue, relevantValue?.context === undefined
+            ? [context]
+            : [...relevantValue.context, context]);
+    }
+    /**
+     * Create an Unvalidated<T> from JSON text.
+     *
+     * Shortcut for creating an Unvalidated<T> from JSON.
+     *
+     * @typeParam T - An interface describing the shape the object should have.
+     * @param json
+     * @param context
+     * @returns
+     */
+    static createFromJSON(json, context) {
+        try {
+            return new Unvalidated(JSON.parse(json), [context]);
+        }
+        catch (e) {
+            throw new Error(`Error parsing json`, { cause: e });
+        }
+    }
+    /**
+     * Access a value from an Unvalidated object.
+     *
+     * returns Unvalidated<undefined> of this key does not exist on the object.
+     *
+     * @param key
+     * @returns
+     */
+    get(key) {
+        if (this.rawValue === undefined) {
+            return new Unvalidated(undefined, [...this.context, key]);
+        }
+        return new Unvalidated(this.rawValue[key], [
+            ...this.context,
+            key
+        ]);
+    }
+    /**
+     * Helper to allow casting parent types to child types.
+     *
+     * Mostly used after type discrimination with {@link validateIsMember}
+     *
+     * @returns
+     */
+    castTo() {
+        return this;
+    }
+    /**
+     * Wrap the Unvalidated's context around an error throw during validation.
+     *
+     * @param cause
+     */
+    throwValidationError(cause) {
+        throw new Error(`In validation context: '${JSON.stringify(this.context)}'`, { cause });
+    }
+}
+/**
+ * Validate possibly undefined value with a custom validator
+ *
+ * @param value
+ * @param validator
+ * @returns
+ */
+export function validateMaybeUndefined(value, validator) {
+    if (value.rawValue === undefined) {
+        return undefined;
+    }
+    return validator(value.castTo());
+}
+/**
+ * Validate that the value is a string.
+ *
+ * @param value
+ * @returns
+ */
+export function validateString(value) {
+    if (typeof value.rawValue !== "string") {
+        value.throwValidationError(new Error(`value is not a string. It is '${typeof value.rawValue}'`));
+    }
+    return value.rawValue;
+}
+/**
+ * Validate that the value is number.
+ * @param value
+ * @returns
+ */
+export function validateNumber(value) {
+    if (typeof value.rawValue !== "number") {
+        value.throwValidationError(new Error(`value is not a number. It is '${typeof value.rawValue}'`));
+    }
+    return value.rawValue;
+}
+/**
+ * Validate that the value is a BigInt.
+ * @param value
+ * @returns
+ */
+export function validateBigInt(value) {
+    if (typeof value.rawValue === "number") {
+        return BigInt(value.rawValue);
+    }
+    if (typeof value.rawValue !== "bigint") {
+        value.throwValidationError(new Error(`value is not a bigint. It is '${typeof value.rawValue}'`));
+    }
+    return value.rawValue;
+}
+/**
+ * Validate that the value us a boolean.
+ * @param value
+ * @returns
+ */
+export function validateBoolean(value) {
+    if (typeof value.rawValue !== "boolean") {
+        value.throwValidationError(new Error(`value is not a boolean. It is '${typeof value.rawValue}'`));
+    }
+    return value.rawValue;
+}
+/**
+ * Validate that the value is an array, using a custom validator for each element.
+ * @param array
+ * @param validator
+ * @returns
+ */
+export function validateArray(array, validator) {
+    if (!Array.isArray(array.rawValue)) {
+        array.throwValidationError(new Error(`value is not an array. It is '${typeof array.rawValue}'`));
+    }
+    return array.rawValue.map((_, index) => {
+        return validator(array.get(index), index);
+    });
+}
+/**
+ * Shortuct for combining {@link validateArray} with {@link validateString}
+ * @param object
+ * @returns
+ */
+export function validateStringArray(object) {
+    return validateArray(object, validateString);
+}
+/**
+ * Validate a Record with string keys with a custom validator for the values.
+ * @param value
+ * @param validator
+ * @returns
+ */
+export function validateObject(value, validator) {
+    const rawValue = value.rawValue;
+    if (typeof rawValue !== "object") {
+        value.throwValidationError(new Error(`value is not an object`));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (rawValue === null) {
+        value.throwValidationError(new Error(`value is null`));
+    }
+    if (Array.isArray(rawValue)) {
+        value.throwValidationError(new Error(`value is not an object. it is an array`));
+    }
+    const resultObject = {};
+    for (const key of Object.keys(rawValue)) {
+        resultObject[key] = validator(value.get(key), key);
+    }
+    return resultObject;
+}
+/**
+ * Validate that value is a string that is a member of group.
+ *
+ * Useful when relying on type discrimination to help figure out which child type to cast a parent type to.
+ * @param value
+ * @param group
+ * @returns
+ */
+export function validateIsMember(value, group) {
+    const stringValue = validateString(value);
+    if (group.has(stringValue)) {
+        return stringValue;
+    }
+    value.throwValidationError(new Error(`'${stringValue}' was not found in '${JSON.stringify([...group])}'`));
+}
+/**
+ * Validate a JSON value.
+ * @param value
+ * @returns
+ */
+export function validateJSONValue(value) {
+    if (value.rawValue === null) {
+        return value.rawValue;
+    }
+    if (value.rawValue === undefined) {
+        return value.rawValue;
+    }
+    switch (typeof value.rawValue) {
+        case "string":
+        case "number":
+        case "boolean":
+            return value.rawValue;
+        case "object": {
+            if (Array.isArray(value.rawValue)) {
+                return validateArray(value.castTo(), validateJSONValue);
+            }
+            return validateJSONObject(value.castTo());
+        }
+        default:
+            value.throwValidationError(new Error(`value is not a json value`));
+    }
+}
+/**
+ * Validate a JSON object.
+ * @param jsonObject
+ * @returns
+ */
+export function validateJSONObject(jsonObject) {
+    return validateObject(jsonObject, validateJSONValue);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../@buildkitchen/validation/index.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * {@include README.md}\n * @packageDocumentation\n */\n/**\n * Represent data who's type hasn't been validated yet.\n *\n * ```typescript\n *  interface Test extends JSONObject {\n *    readonly foo: string;\n *    readonly x: number;\n *  }\n *  const test = JSON.stringify({foo: \"bar\", x: 42})\n *  const unvalidated = Unvalidated.createFromJSON<Test>(test, \"loaded from helloWorld.txt\");\n *  validateString(unvalidated.get(\"foo\")); // \"bar\"\n *  validateNumber(unvalidated.get(\"x\")); // 42\n *\n *  // Typescript won't compile because foo1 is not a member of the validated type.\n *  // Also paired with a runtime error.\n *  validateString(unvalidated.get(\"foo1\"));\n * ```\n *\n *\n * @typeParam T - An interface describing the shape the object should have. Used in the typing of {@link Unvalidated.get}\n * to statically enforce type safety.\n */\nexport class Unvalidated<T> {\n  // This makes sure that each instance of Unvalidated isn't ducktyped to each other\n  /** @internal */\n  readonly __typeCheck: T;\n  /**\n   * Creates an instance of UserProfile.\n   *\n   * @param rawValue The unvalidated data. Allows direct access for complex validation cases.\n   * @param context Context used for reporting errors during validation.\n   */\n  private constructor(\n    public readonly rawValue: unknown,\n    public readonly context: ReadonlyArray<string | number>\n  ) {\n    this.__typeCheck = undefined as unknown as T;\n  }\n\n  /**\n   * Create an Unvalidated<T> from an in-memory object.\n   *\n   * Useful when getting data from a source who's schema still needs to be checked i.e. database results etc.\n   *\n   * @typeParam T - An interface describing the shape the object should have.\n   * @param rawValue\n   * @param context\n   * @param relevantValue\n   * @returns\n   */\n  static create<T>(\n    rawValue: T,\n    context: string | number,\n    relevantValue?: Unvalidated<unknown>\n  ): Unvalidated<T> {\n    return new Unvalidated(\n      rawValue,\n      relevantValue?.context === undefined\n        ? [context]\n        : [...relevantValue.context, context]\n    );\n  }\n\n  /**\n   * Create an Unvalidated<T> from JSON text.\n   *\n   * Shortcut for creating an Unvalidated<T> from JSON.\n   *\n   * @typeParam T - An interface describing the shape the object should have.\n   * @param json\n   * @param context\n   * @returns\n   */\n  static createFromJSON<T extends JSONValue>(\n    json: string,\n    context: string\n  ): Unvalidated<T> {\n    try {\n      return new Unvalidated(JSON.parse(json) as T, [context]);\n    } catch (e) {\n      throw new Error(`Error parsing json`, { cause: e });\n    }\n  }\n\n  /**\n   * Access a value from an Unvalidated object.\n   *\n   * returns Unvalidated<undefined> of this key does not exist on the object.\n   *\n   * @param key\n   * @returns\n   */\n  get<K extends (T extends undefined ? never : keyof T)>(\n    key: K & (string | number)\n  ): Unvalidated<T extends undefined ? undefined : T[K]> {\n    if (this.rawValue === undefined) {\n      return new Unvalidated(undefined, [...this.context, key]);\n    }\n    return new Unvalidated((this.rawValue as Exclude<T, undefined>)[key], [\n      ...this.context,\n      key\n    ]);\n  }\n\n  /**\n   * Helper to allow casting parent types to child types.\n   *\n   * Mostly used after type discrimination with {@link validateIsMember}\n   *\n   * @returns\n   */\n  castTo<U extends T>(): Unvalidated<U> {\n    return this as unknown as Unvalidated<U>;\n  }\n\n  /**\n   * Wrap the Unvalidated's context around an error throw during validation.\n   *\n   * @param cause\n   */\n  throwValidationError(cause: Error): never {\n    throw new Error(\n      `In validation context: '${JSON.stringify(this.context)}'`,\n      { cause }\n    );\n  }\n}\n\n/**\n * Validate possibly undefined value with a custom validator\n *\n * @param value\n * @param validator\n * @returns\n */\nexport function validateMaybeUndefined<T, V>(\n  value: Unvalidated<T | undefined>,\n  validator: (value: Unvalidated<T>) => V\n): V | undefined {\n  if (value.rawValue === undefined) {\n    return undefined;\n  }\n  return validator(value.castTo<T>());\n}\n\n/**\n * Validate that the value is a string.\n *\n * @param value\n * @returns\n */\nexport function validateString(value: Unvalidated<string>): string {\n  if (typeof value.rawValue !== \"string\") {\n    value.throwValidationError(\n      new Error(`value is not a string. It is '${typeof value.rawValue}'`)\n    );\n  }\n  return value.rawValue;\n}\n\n/**\n * Validate that the value is number.\n * @param value\n * @returns\n */\nexport function validateNumber(value: Unvalidated<number>): number {\n  if (typeof value.rawValue !== \"number\") {\n    value.throwValidationError(\n      new Error(`value is not a number. It is '${typeof value.rawValue}'`)\n    );\n  }\n  return value.rawValue;\n}\n\n/**\n * Validate that the value is a BigInt.\n * @param value\n * @returns\n */\nexport function validateBigInt(value: Unvalidated<bigint>): bigint {\n  if (typeof value.rawValue === \"number\") {\n    return BigInt(value.rawValue);\n  }\n  if (typeof value.rawValue !== \"bigint\") {\n    value.throwValidationError(\n      new Error(`value is not a bigint. It is '${typeof value.rawValue}'`)\n    );\n  }\n  return value.rawValue;\n}\n\n/**\n * Validate that the value us a boolean.\n * @param value\n * @returns\n */\nexport function validateBoolean(value: Unvalidated<boolean>): boolean {\n  if (typeof value.rawValue !== \"boolean\") {\n    value.throwValidationError(\n      new Error(`value is not a boolean. It is '${typeof value.rawValue}'`)\n    );\n  }\n  return value.rawValue;\n}\n\n/**\n * Validate that the value is an array, using a custom validator for each element.\n * @param array\n * @param validator\n * @returns\n */\nexport function validateArray<T, V = T>(\n  array: Unvalidated<ReadonlyArray<T>>,\n  validator: (object: Unvalidated<T>, index: number) => V\n): Array<V> {\n  if (!Array.isArray(array.rawValue)) {\n    array.throwValidationError(\n      new Error(`value is not an array. It is '${typeof array.rawValue}'`)\n    );\n  }\n  return array.rawValue.map((_, index) => {\n    return validator(array.get(index), index);\n  });\n}\n\n/**\n * Shortuct for combining {@link validateArray} with {@link validateString}\n * @param object\n * @returns\n */\nexport function validateStringArray(\n  object: Unvalidated<ReadonlyArray<string>>\n): ReadonlyArray<string> {\n  return validateArray(object, validateString);\n}\n\n/**\n * Validate a Record with string keys with a custom validator for the values.\n * @param value\n * @param validator\n * @returns\n */\nexport function validateObject<T, S>(\n  value: Unvalidated<Record<string, T>>,\n  validator: (unvalidated: Unvalidated<T>, key: string) => S\n): Record<string, S> {\n  const rawValue = value.rawValue as Record<string, T>;\n  if (typeof rawValue !== \"object\") {\n    value.throwValidationError(new Error(`value is not an object`));\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n  if (rawValue === null) {\n    value.throwValidationError(new Error(`value is null`));\n  }\n\n  if (Array.isArray(rawValue)) {\n    value.throwValidationError(\n      new Error(`value is not an object. it is an array`)\n    );\n  }\n\n  const resultObject: Record<string, S> = {};\n  for (const key of Object.keys(rawValue)) {\n    resultObject[key] = validator(value.get(key), key);\n  }\n  return resultObject;\n}\n\n/**\n * Validate that value is a string that is a member of group.\n *\n * Useful when relying on type discrimination to help figure out which child type to cast a parent type to.\n * @param value\n * @param group\n * @returns\n */\nexport function validateIsMember<S extends string>(\n  value: Unvalidated<S>,\n  group: ReadonlySet<S>\n): S {\n  const stringValue = validateString(value);\n  if (group.has(stringValue as S)) {\n    return stringValue as S;\n  }\n  value.throwValidationError(\n    new Error(\n      `'${stringValue}' was not found in '${JSON.stringify([...group])}'`\n    )\n  );\n}\n\nexport type JSONPrimitive = string | number | boolean | null | undefined;\nexport type JSONValue = JSONPrimitive | JSONObject | ReadonlyArray<JSONValue>;\nexport interface JSONObject {\n  [key: string]: JSONValue | undefined;\n}\n\n/**\n * Validate a JSON value.\n * @param value\n * @returns\n */\nexport function validateJSONValue(value: Unvalidated<JSONValue>): JSONValue {\n  if (value.rawValue === null) {\n    return value.rawValue;\n  }\n  if (value.rawValue === undefined) {\n    return value.rawValue;\n  }\n\n  switch (typeof value.rawValue) {\n    case \"string\":\n    case \"number\":\n    case \"boolean\":\n      return value.rawValue;\n    case \"object\": {\n      if (Array.isArray(value.rawValue)) {\n        return validateArray(\n          value.castTo<ReadonlyArray<JSONValue>>(),\n          validateJSONValue\n        );\n      }\n      return validateJSONObject(value.castTo<JSONObject>());\n    }\n    default:\n      value.throwValidationError(new Error(`value is not a json value`));\n  }\n}\n\n/**\n * Validate a JSON object.\n * @param jsonObject\n * @returns\n */\nexport function validateJSONObject(\n  jsonObject: Unvalidated<JSONObject>\n): JSONObject {\n  return validateObject(jsonObject, validateJSONValue);\n}\n"]}

package/package.json

@@ -1,6 +1,25 @@
 {
+  "description": "Library for validiating JSON-adjacent types",
+  "homepage": "https://codeberg.org/buildkitchen/validation",
+  "bugs": {
+    "url": "https://codeberg.org/buildkitchen/validation"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Kwasi Mensah",
+    "email": "kwasi.mensah@gmail.com"
+  },
+  "keywords": [
+    "validation",
+    "serialize",
+    "json"
+  ],
   "name": "@buildkitchen/validation",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "bin": {},
+  "private": false,
+  "version": "0.0.1",
+  "__ananse": "Generated by ananse build",
+  "type": "module",
+  "bundledDependencies": [],
+  "dependencies": {}
 }