@oscarpalmer/jhunal 0.14.0 → 0.16.0

package/dist/helpers.js

@@ -1,12 +0,0 @@
-import { MESSAGE_CONSTRUCTOR } from "./constants.js";
-import { isConstructor } from "@oscarpalmer/atoms/is";
-function instanceOf(constructor) {
-	if (!isConstructor(constructor)) throw new TypeError(MESSAGE_CONSTRUCTOR);
-	return (value) => {
-		return value instanceof constructor;
-	};
-}
-function isSchematic(value) {
-	return typeof value === "object" && value !== null && "$schematic" in value && value["$schematic"] === true;
-}
-export { instanceOf, isSchematic };

package/dist/index.js

@@ -1,4 +0,0 @@
-import { instanceOf } from "./helpers.js";
-import { SchematicError } from "./models.js";
-import { schematic } from "./schematic.js";
-export { SchematicError, instanceOf, schematic };

package/dist/models.js

@@ -1,8 +0,0 @@
-import { ERROR_NAME } from "./constants.js";
-var SchematicError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = ERROR_NAME;
-	}
-};
-export { SchematicError };

package/dist/node_modules/@oscarpalmer/atoms/dist/internal/array/compact.js

@@ -1,12 +0,0 @@
-function compact(array, strict) {
-	if (!Array.isArray(array)) return [];
-	if (strict === true) return array.filter(Boolean);
-	const { length } = array;
-	const compacted = [];
-	for (let index = 0; index < length; index += 1) {
-		const item = array[index];
-		if (item != null) compacted.push(item);
-	}
-	return compacted;
-}
-export { compact };

package/dist/node_modules/@oscarpalmer/atoms/dist/internal/string.js

@@ -1,24 +0,0 @@
-import { compact } from "./array/compact.js";
-/**
-* Get the string value from any value
-* @param value Original value
-* @returns String representation of the value
-*/
-function getString(value) {
-	if (typeof value === "string") return value;
-	if (value == null) return "";
-	if (typeof value === "function") return getString(value());
-	if (typeof value !== "object") return String(value);
-	const asString = String(value.valueOf?.() ?? value);
-	return asString.startsWith("[object ") ? JSON.stringify(value) : asString;
-}
-/**
-* Join an array of values into a string
-* @param value Array of values
-* @param delimiter Delimiter to use between values
-* @returns Joined string
-*/
-function join(value, delimiter) {
-	return compact(value).map(getString).join(typeof delimiter === "string" ? delimiter : "");
-}
-export { join };

package/types/constants.d.ts

@@ -1,22 +0,0 @@
-export declare const ERROR_NAME = "SchematicError";
-export declare const EXPRESSION_PROPERTY: RegExp;
-export declare const MESSAGE_CONSTRUCTOR = "Expected a constructor function";
-export declare const MESSAGE_SCHEMA_INVALID_EMPTY = "Schema must have at least one property";
-export declare const MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED = "'<key>.<property>' property is not allowed for schemas in $type";
-export declare const MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED = "'<>.$required' property must be a boolean";
-export declare const MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE = "'<>' property must be of a valid type";
-export declare const MESSAGE_SCHEMA_INVALID_TYPE = "Schema must be an object";
-export declare const MESSAGE_VALIDATOR_INVALID_KEY = "Validator '<>' does not exist";
-export declare const MESSAGE_VALIDATOR_INVALID_TYPE = "Validators must be an object";
-export declare const MESSAGE_VALIDATOR_INVALID_VALUE = "Validator '<>' must be a function or an array of functions";
-export declare const PROPERTY_REQUIRED = "$required";
-export declare const PROPERTY_TYPE = "$type";
-export declare const PROPERTY_VALIDATORS = "$validators";
-export declare const SCHEMATIC_NAME = "$schematic";
-export declare const TEMPLATE_PATTERN = "<>";
-export declare const TEMPLATE_PATTERN_KEY = "<key>";
-export declare const TEMPLATE_PATTERN_PROPERTY = "<property>";
-export declare const TYPE_OBJECT = "object";
-export declare const TYPE_UNDEFINED = "undefined";
-export declare const VALIDATABLE_TYPES: Set<keyof import("./models").Values>;
-export declare const TYPE_ALL: Set<keyof import("./models").Values>;

package/types/helpers.d.ts

@@ -1,4 +0,0 @@
-import type { Constructor } from './models';
-import type { Schematic } from './schematic';
-export declare function instanceOf<Instance>(constructor: Constructor<Instance>): (value: unknown) => value is Instance;
-export declare function isSchematic(value: unknown): value is Schematic<never>;

package/types/index.d.ts

@@ -1,3 +0,0 @@
-export { instanceOf } from './helpers';
-export { SchematicError, type Schema, type TypedSchema } from './models';
-export { schematic, type Schematic } from './schematic';

package/types/models.d.ts

@@ -1,158 +0,0 @@
-import type { GenericCallback, PlainObject, Simplify } from '@oscarpalmer/atoms/models';
-import type { Schematic } from './schematic';
-export type Constructor<Instance = any> = new (...args: any[]) => Instance;
-type DeduplicateTuple<Value extends unknown[], Seen extends unknown[] = []> = Value extends [
-    infer Head,
-    ...infer Tail
-] ? Head extends Seen[number] ? DeduplicateTuple<Tail, Seen> : DeduplicateTuple<Tail, [...Seen, Head]> : Seen;
-type ExtractValueNames<Value> = Value extends ValueName ? Value : Value extends (infer Item)[] ? ExtractValueNames<Item> : Value extends readonly (infer Item)[] ? ExtractValueNames<Item> : never;
-/**
- * Infer the TypeScript type from a schema definition
- */
-export type Infer<Model extends Schema> = Simplify<{
-    [Key in InferRequiredKeys<Model>]: InferSchemaEntry<Model[Key]>;
-} & {
-    [Key in InferOptionalKeys<Model>]?: InferSchemaEntry<Model[Key]>;
-}>;
-type InferOptionalKeys<Model extends Schema> = keyof {
-    [Key in keyof Model as IsOptionalProperty<Model[Key]> extends true ? Key : never]: never;
-};
-type InferPropertyType<Value> = Value extends (infer Item)[] ? InferPropertyValue<Item> : InferPropertyValue<Value>;
-type InferPropertyValue<Value> = Value extends Constructor<infer Instance> ? Instance : Value extends Schematic<infer Model> ? Model : Value extends ValueName ? Values[Value & ValueName] : Value extends Schema ? Infer<Value> : never;
-type InferRequiredKeys<Model extends Schema> = keyof {
-    [Key in keyof Model as IsOptionalProperty<Model[Key]> extends true ? never : Key]: never;
-};
-type InferSchemaEntry<Value> = Value extends (infer Item)[] ? InferSchemaEntryValue<Item> : InferSchemaEntryValue<Value>;
-type InferSchemaEntryValue<Value> = Value extends Constructor<infer Instance> ? Instance : Value extends Schematic<infer Model> ? Model : Value extends SchemaProperty ? InferPropertyType<Value['$type']> : Value extends NestedSchema ? Infer<Omit<Value, '$required'>> : Value extends ValueName ? Values[Value & ValueName] : Value extends Schema ? Infer<Value> : never;
-type IsOptionalProperty<Value> = Value extends SchemaProperty ? Value['$required'] extends false ? true : false : Value extends {
-    $required?: boolean;
-} ? Value extends {
-    $required: false;
-} ? true : false : false;
-type LastOfUnion<Value> = UnionToIntersection<Value extends unknown ? () => Value : never> extends () => infer Item ? Item : never;
-type MapToValueTypes<Value extends unknown[]> = Value extends [infer Head, ...infer Tail] ? [ToValueType<Head>, ...MapToValueTypes<Tail>] : [];
-type MapToSchemaPropertyTypes<Value extends unknown[]> = Value extends [infer Head, ...infer Tail] ? [ToSchemaPropertyTypeEach<Head>, ...MapToSchemaPropertyTypes<Tail>] : [];
-/**
- * A nested schema with optional requirement flag
- */
-export type NestedSchema = {
-    $required?: boolean;
-    [key: string]: any;
-};
-type OptionalKeys<Value> = {
-    [Key in keyof Value]-?: {} extends Pick<Value, Key> ? Key : never;
-}[keyof Value];
-type PlainSchema = {
-    [key: string]: NestedSchema | SchemaEntry | SchemaEntry[];
-};
-type PropertyValidators<Value> = {
-    [Key in ExtractValueNames<Value>]?: ((value: Values[Key]) => boolean) | Array<(value: Values[Key]) => boolean>;
-};
-type RequiredKeys<Value> = Exclude<keyof Value, OptionalKeys<Value>>;
-/**
- * A schema for validating objects
- */
-export type Schema = SchemaIndex;
-type SchemaEntry = Constructor | Schema | SchemaProperty | Schematic<unknown> | ValueName | ((value: unknown) => boolean);
-interface SchemaIndex {
-    [key: string]: NestedSchema | SchemaEntry | SchemaEntry[];
-}
-/**
- * A property definition with explicit type(s), optional requirement flag, and optional validators
- */
-export type SchemaProperty = {
-    $required?: boolean;
-    $type: SchemaPropertyType | SchemaPropertyType[];
-    $validators?: PropertyValidators<SchemaPropertyType | SchemaPropertyType[]>;
-};
-type SchemaPropertyType = Constructor | PlainSchema | Schematic<unknown> | ValueName | ((value: unknown) => boolean);
-export declare class SchematicError extends Error {
-    constructor(message: string);
-}
-type ToSchemaPropertyType<Value> = UnwrapSingle<DeduplicateTuple<MapToSchemaPropertyTypes<UnionToTuple<Value>>>>;
-type ToSchemaPropertyTypeEach<Value> = Value extends NestedSchema ? Omit<Value, '$required'> : Value extends PlainObject ? TypedSchema<Value> : ToValueType<Value>;
-type ToSchemaType<Value> = UnwrapSingle<DeduplicateTuple<MapToValueTypes<UnionToTuple<Value>>>>;
-type ToValueType<Value> = Value extends unknown[] ? 'array' : Value extends bigint ? 'bigint' : Value extends boolean ? 'boolean' : Value extends Date ? 'date' : Value extends Schematic<any> ? Value : Value extends Function ? 'function' : Value extends null ? 'null' : Value extends number ? 'number' : Value extends object ? 'object' | ((value: unknown) => value is Value) : Value extends string ? 'string' : Value extends symbol ? 'symbol' : Value extends undefined ? 'undefined' : (value: unknown) => value is Value;
-type TuplePermutations<Tuple extends unknown[], Elput extends unknown[] = []> = Tuple['length'] extends 0 ? Elput : {
-    [Key in keyof Tuple]: TuplePermutations<TupleRemoveAt<Tuple, Key & `${number}`>, [
-        ...Elput,
-        Tuple[Key]
-    ]>;
-}[keyof Tuple & `${number}`];
-type TupleRemoveAt<Items extends unknown[], Item extends string, Prefix extends unknown[] = []> = Items extends [infer Head, ...infer Tail] ? `${Prefix['length']}` extends Item ? [...Prefix, ...Tail] : TupleRemoveAt<Tail, Item, [...Prefix, Head]> : Prefix;
-export type TypedPropertyOptional<Value> = {
-    /**
-     * The property is not required
-     */
-    $required: false;
-    /**
-     * The type(s) of the property
-     */
-    $type: ToSchemaPropertyType<Exclude<Value, undefined>>;
-    /**
-     * Custom validators for the property and its types
-     */
-    $validators?: PropertyValidators<ToSchemaPropertyType<Exclude<Value, undefined>>>;
-};
-export type TypedPropertyRequired<Value> = {
-    /**
-     * The property is required _(defaults to `true`)_
-     */
-    $required?: true;
-    /**
-     * The type(s) of the property
-     */
-    $type: ToSchemaPropertyType<Value>;
-    /**
-     * Custom validators for the property and its types
-     */
-    $validators?: PropertyValidators<ToSchemaPropertyType<Value>>;
-};
-/**
- * Create a schema type constrained to match a TypeScript type
- */
-export type TypedSchema<Model extends PlainObject> = Simplify<{
-    [Key in RequiredKeys<Model>]: Model[Key] extends PlainObject ? TypedSchemaRequired<Model[Key]> | Schematic<Model[Key]> : ToSchemaType<Model[Key]> | TypedPropertyRequired<Model[Key]>;
-} & {
-    [Key in OptionalKeys<Model>]: Exclude<Model[Key], undefined> extends PlainObject ? TypedSchemaOptional<Exclude<Model[Key], undefined>> | Schematic<Exclude<Model[Key], undefined>> : TypedPropertyOptional<Model[Key]>;
-}>;
-type TypedSchemaOptional<Model extends PlainObject> = {
-    $required: false;
-} & TypedSchema<Model>;
-type TypedSchemaRequired<Model extends PlainObject> = {
-    $required?: true;
-} & TypedSchema<Model>;
-type UnionToIntersection<Value> = (Value extends unknown ? (value: Value) => void : never) extends (value: infer Item) => void ? Item : never;
-type UnionToTuple<Value, Items extends unknown[] = []> = [Value] extends [never] ? Items : UnionToTuple<Exclude<Value, LastOfUnion<Value>>, [LastOfUnion<Value>, ...Items]>;
-type UnwrapSingle<Value extends unknown[]> = Value extends [infer Only] ? Only : Value['length'] extends 1 | 2 | 3 | 4 | 5 ? TuplePermutations<Value> : Value;
-export type ValidatedProperty = {
-    key: string;
-    required: boolean;
-    types: ValidatedPropertyType[];
-    validators: ValidatedPropertyValidators;
-};
-export type ValidatedPropertyType = GenericCallback | Schematic<unknown> | ValidatedProperty | ValueName;
-export type ValidatedPropertyValidators = {
-    [Key in ValueName]?: Array<(value: unknown) => boolean>;
-};
-/**
- * Valid type name strings
- */
-export type ValueName = keyof Values;
-/**
- * Map of type names to their TypeScript/validatable equivalents
- */
-export type Values = {
-    array: unknown[];
-    bigint: bigint;
-    boolean: boolean;
-    date: Date;
-    function: Function;
-    null: null;
-    number: number;
-    object: object;
-    string: string;
-    symbol: symbol;
-    undefined: undefined;
-};
-export {};

package/types/schematic.d.ts

@@ -1,22 +0,0 @@
-import type { PlainObject } from '@oscarpalmer/atoms/models';
-import { type Infer, type Schema, type TypedSchema, type ValidatedProperty } from './models';
-/**
- * A schematic for validating objects
- */
-export declare class Schematic<Model> {
-    #private;
-    private readonly $schematic;
-    constructor(properties: ValidatedProperty[]);
-    /**
-     * Does the value match the schema?
-     */
-    is(value: unknown): value is Model;
-}
-/**
- * Create a schematic from a schema
- */
-export declare function schematic<Model extends Schema>(schema: Model): Schematic<Infer<Model>>;
-/**
- * Create a schematic from a typed schema
- */
-export declare function schematic<Model extends PlainObject>(schema: TypedSchema<Model>): Schematic<Model>;

package/types/validation/property.validation.d.ts

@@ -1,3 +0,0 @@
-import type { PlainObject } from '@oscarpalmer/atoms/models';
-import { type ValidatedProperty } from '../models';
-export declare function getProperties(original: PlainObject, prefix?: string, fromType?: boolean): ValidatedProperty[];

package/types/validation/value.validation.d.ts

@@ -1,2 +0,0 @@
-import type { ValidatedProperty } from '../models';
-export declare function validateObject(obj: unknown, properties: ValidatedProperty[]): boolean;