@oscarpalmer/jhunal 0.4.0 → 0.5.0

package/dist/validation/type.validation.cjs

@@ -1,33 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-const is = require('../is.cjs');
-const validation_value_validation = require('./value.validation.cjs');
-
-function validateType(type, value) {
-  if (typeof type === "string") {
-    return validators[type](value);
-  }
-  if (is.isSchematic(type)) {
-    return type.is(value);
-  }
-  return validation_value_validation.validateValue(type, value);
-}
-const validators = {
-  array: Array.isArray,
-  bigint: (value) => typeof value === "bigint",
-  boolean: (value) => typeof value === "boolean",
-  date: (value) => value instanceof Date,
-  "date-like": is.isDateLike,
-  function: (value) => typeof value === "function",
-  null: (value) => value === null,
-  number: (value) => typeof value === "number",
-  numerical: (value) => validators.bigint(value) || validators.number(value),
-  object: (value) => typeof value === "object" && value !== null,
-  string: (value) => typeof value === "string",
-  symbol: (value) => typeof value === "symbol",
-  undefined: (value) => value === void 0
-};
-
-exports.validateType = validateType;

package/dist/validation/type.validation.js

@@ -1,29 +0,0 @@
-import { isDateLike, isSchematic } from '../is.js';
-import { validateValue } from './value.validation.js';
-
-function validateType(type, value) {
-  if (typeof type === "string") {
-    return validators[type](value);
-  }
-  if (isSchematic(type)) {
-    return type.is(value);
-  }
-  return validateValue(type, value);
-}
-const validators = {
-  array: Array.isArray,
-  bigint: (value) => typeof value === "bigint",
-  boolean: (value) => typeof value === "boolean",
-  date: (value) => value instanceof Date,
-  "date-like": isDateLike,
-  function: (value) => typeof value === "function",
-  null: (value) => value === null,
-  number: (value) => typeof value === "number",
-  numerical: (value) => validators.bigint(value) || validators.number(value),
-  object: (value) => typeof value === "object" && value !== null,
-  string: (value) => typeof value === "string",
-  symbol: (value) => typeof value === "symbol",
-  undefined: (value) => value === void 0
-};
-
-export { validateType };

package/dist/validation/value.validation.cjs

@@ -1,35 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-const validation_type_validation = require('./type.validation.cjs');
-
-function validateValue(validated, obj) {
-  if (typeof obj !== "object" || obj === null) {
-    return false;
-  }
-  outer: for (let keyIndex = 0; keyIndex < validated.length; keyIndex += 1) {
-    const key = validated.keys[keyIndex];
-    const property = validated.properties[key];
-    const value = obj[key];
-    if (value === void 0 && property.required && !property.types.includes("undefined")) {
-      return false;
-    }
-    const typesLength = property.types.length;
-    if (typesLength === 1) {
-      if (!validation_type_validation.validateType(property.types[0], value)) {
-        return false;
-      }
-      continue;
-    }
-    for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
-      if (validation_type_validation.validateType(property.types[typeIndex], value)) {
-        continue outer;
-      }
-    }
-    return false;
-  }
-  return true;
-}
-
-exports.validateValue = validateValue;

package/src/validation/type.validation.ts

@@ -1,34 +0,0 @@
-import {isDateLike, isSchematic} from '../is';
-import type {ValidatedPropertyType, ValidatedSchema, Values} from '../model';
-import {validateValue} from './value.validation';
-
-export function validateType(
-	type: ValidatedPropertyType,
-	value: unknown,
-): boolean {
-	if (typeof type === 'string') {
-		return validators[type](value);
-	}
-
-	if (isSchematic(type)) {
-		return type.is(value);
-	}
-
-	return validateValue(type as ValidatedSchema, value);
-}
-
-const validators: Record<keyof Values, (value: unknown) => boolean> = {
-	array: Array.isArray,
-	bigint: value => typeof value === 'bigint',
-	boolean: value => typeof value === 'boolean',
-	date: value => value instanceof Date,
-	'date-like': isDateLike,
-	function: value => typeof value === 'function',
-	null: value => value === null,
-	number: value => typeof value === 'number',
-	numerical: value => validators.bigint(value) || validators.number(value),
-	object: value => typeof value === 'object' && value !== null,
-	string: value => typeof value === 'string',
-	symbol: value => typeof value === 'symbol',
-	undefined: value => value === undefined,
-};

package/types/helpers.d.cts

@@ -1,43 +0,0 @@
-// Generated by dts-bundle-generator v9.5.1
-
-/**
- * A schematic for validating objects
- */
-export type Schematic<Model> = {
-	/**
-	 * Does the value match the schema?
-	 */
-	is(value: unknown): value is Model;
-};
-export type ValidatedProperty = {
-	required: boolean;
-	types: ValidatedPropertyType[];
-};
-export type ValidatedPropertyType = Schematic<unknown> | ValidatedSchema | ValueKey;
-export type ValidatedSchema = {
-	keys: string[];
-	length: number;
-	properties: ValidatedSchemaProperties;
-};
-export type ValidatedSchemaProperties = {
-	[key: string]: ValidatedProperty;
-};
-export type ValueKey = keyof Values;
-export type Values = {
-	array: unknown[];
-	bigint: bigint;
-	boolean: boolean;
-	date: Date;
-	"date-like": number | string | Date;
-	function: Function;
-	null: null;
-	number: number;
-	numerical: bigint | number;
-	object: object;
-	string: string;
-	symbol: symbol;
-	undefined: undefined;
-};
-export declare function getTypes(value: unknown): ValidatedPropertyType[];
-
-export {};

package/types/index.d.cts

@@ -1,360 +0,0 @@
-// Generated by dts-bundle-generator v9.5.1
-
-/**
-Convert a union type to an intersection type using [distributive conditional types](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
-
-Inspired by [this Stack Overflow answer](https://stackoverflow.com/a/50375286/2172153).
-
-@example
-```
-import type {UnionToIntersection} from 'type-fest';
-
-type Union = {the(): void} | {great(arg: string): void} | {escape: boolean};
-
-type Intersection = UnionToIntersection<Union>;
-//=> {the(): void; great(arg: string): void; escape: boolean};
-```
-
-A more applicable example which could make its way into your library code follows.
-
-@example
-```
-import type {UnionToIntersection} from 'type-fest';
-
-class CommandOne {
-	commands: {
-		a1: () => undefined,
-		b1: () => undefined,
-	}
-}
-
-class CommandTwo {
-	commands: {
-		a2: (argA: string) => undefined,
-		b2: (argB: string) => undefined,
-	}
-}
-
-const union = [new CommandOne(), new CommandTwo()].map(instance => instance.commands);
-type Union = typeof union;
-//=> {a1(): void; b1(): void} | {a2(argA: string): void; b2(argB: string): void}
-
-type Intersection = UnionToIntersection<Union>;
-//=> {a1(): void; b1(): void; a2(argA: string): void; b2(argB: string): void}
-```
-
-@category Type
-*/
-export type UnionToIntersection<Union> = (
-// `extends unknown` is always going to be the case and is used to convert the
-// `Union` into a [distributive conditional
-// type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
-Union extends unknown ? (distributedUnion: Union) => void : never) extends ((mergedIntersection: infer Intersection) => void) ? Intersection & Union : never;
-/**
-Extract all optional keys from the given type.
-
-This is useful when you want to create a new type that contains different type values for the optional keys only.
-
-@example
-```
-import type {OptionalKeysOf, Except} from 'type-fest';
-
-interface User {
-	name: string;
-	surname: string;
-
-	luckyNumber?: number;
-}
-
-const REMOVE_FIELD = Symbol('remove field symbol');
-type UpdateOperation<Entity extends object> = Except<Partial<Entity>, OptionalKeysOf<Entity>> & {
-	[Key in OptionalKeysOf<Entity>]?: Entity[Key] | typeof REMOVE_FIELD;
-};
-
-const update1: UpdateOperation<User> = {
-	name: 'Alice'
-};
-
-const update2: UpdateOperation<User> = {
-	name: 'Bob',
-	luckyNumber: REMOVE_FIELD
-};
-```
-
-@category Utilities
-*/
-export type OptionalKeysOf<BaseType extends object> = BaseType extends unknown // For distributing `BaseType`
- ? (keyof {
-	[Key in keyof BaseType as BaseType extends Record<Key, BaseType[Key]> ? never : Key]: never;
-}) & (keyof BaseType) // Intersect with `keyof BaseType` to ensure result of `OptionalKeysOf<BaseType>` is always assignable to `keyof BaseType`
- : never; // Should never happen
-/**
-Extract all required keys from the given type.
-
-This is useful when you want to create a new type that contains different type values for the required keys only or use the list of keys for validation purposes, etc...
-
-@example
-```
-import type {RequiredKeysOf} from 'type-fest';
-
-declare function createValidation<Entity extends object, Key extends RequiredKeysOf<Entity> = RequiredKeysOf<Entity>>(field: Key, validator: (value: Entity[Key]) => boolean): ValidatorFn;
-
-interface User {
-	name: string;
-	surname: string;
-
-	luckyNumber?: number;
-}
-
-const validator1 = createValidation<User>('name', value => value.length < 25);
-const validator2 = createValidation<User>('surname', value => value.length < 25);
-```
-
-@category Utilities
-*/
-export type RequiredKeysOf<BaseType extends object> = BaseType extends unknown // For distributing `BaseType`
- ? Exclude<keyof BaseType, OptionalKeysOf<BaseType>> : never; // Should never happen
-/**
-Returns a boolean for whether the given type is `never`.
-
-@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
-@link https://stackoverflow.com/a/53984913/10292952
-@link https://www.zhenghao.io/posts/ts-never
-
-Useful in type utilities, such as checking if something does not occur.
-
-@example
-```
-import type {IsNever, And} from 'type-fest';
-
-// https://github.com/andnp/SimplyTyped/blob/master/src/types/strings.ts
-type AreStringsEqual<A extends string, B extends string> =
-	And<
-		IsNever<Exclude<A, B>> extends true ? true : false,
-		IsNever<Exclude<B, A>> extends true ? true : false
-	>;
-
-type EndIfEqual<I extends string, O extends string> =
-	AreStringsEqual<I, O> extends true
-		? never
-		: void;
-
-function endIfEqual<I extends string, O extends string>(input: I, output: O): EndIfEqual<I, O> {
-	if (input === output) {
-		process.exit(0);
-	}
-}
-
-endIfEqual('abc', 'abc');
-//=> never
-
-endIfEqual('abc', '123');
-//=> void
-```
-
-@category Type Guard
-@category Utilities
-*/
-export type IsNever<T> = [
-	T
-] extends [
-	never
-] ? true : false;
-/**
-Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
-
-@example
-```
-import type {Simplify} from 'type-fest';
-
-type PositionProps = {
-	top: number;
-	left: number;
-};
-
-type SizeProps = {
-	width: number;
-	height: number;
-};
-
-// In your editor, hovering over `Props` will show a flattened object with all the properties.
-type Props = Simplify<PositionProps & SizeProps>;
-```
-
-Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.
-
-If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.
-
-@example
-```
-import type {Simplify} from 'type-fest';
-
-interface SomeInterface {
-	foo: number;
-	bar?: string;
-	baz: number | undefined;
-}
-
-type SomeType = {
-	foo: number;
-	bar?: string;
-	baz: number | undefined;
-};
-
-const literal = {foo: 123, bar: 'hello', baz: 456};
-const someType: SomeType = literal;
-const someInterface: SomeInterface = literal;
-
-function fn(object: Record<string, unknown>): void {}
-
-fn(literal); // Good: literal object type is sealed
-fn(someType); // Good: type is sealed
-fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
-fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
-```
-
-@link https://github.com/microsoft/TypeScript/issues/15300
-@see SimplifyDeep
-@category Object
-*/
-export type Simplify<T> = {
-	[KeyType in keyof T]: T[KeyType];
-} & {};
-/**
-Returns the last element of a union type.
-
-@example
-```
-type Last = LastOfUnion<1 | 2 | 3>;
-//=> 3
-```
-*/
-export type LastOfUnion<T> = UnionToIntersection<T extends any ? () => T : never> extends () => (infer R) ? R : never;
-/**
-Convert a union type into an unordered tuple type of its elements.
-
-"Unordered" means the elements of the tuple are not guaranteed to be in the same order as in the union type. The arrangement can appear random and may change at any time.
-
-This can be useful when you have objects with a finite set of keys and want a type defining only the allowed keys, but do not want to repeat yourself.
-
-@example
-```
-import type {UnionToTuple} from 'type-fest';
-
-type Numbers = 1 | 2 | 3;
-type NumbersTuple = UnionToTuple<Numbers>;
-//=> [1, 2, 3]
-```
-
-@example
-```
-import type {UnionToTuple} from 'type-fest';
-
-const pets = {
-  dog: '🐶',
-  cat: '🐱',
-  snake: '🐍',
-};
-
-type Pet = keyof typeof pets;
-//=> 'dog' | 'cat' | 'snake'
-
-const petList = Object.keys(pets) as UnionToTuple<Pet>;
-//=> ['dog', 'cat', 'snake']
-```
-
-@category Array
-*/
-export type UnionToTuple<T, L = LastOfUnion<T>> = IsNever<T> extends false ? [
-	...UnionToTuple<Exclude<T, L>>,
-	L
-] : [
-];
-export type AutoInferExclude = "date-like" | "numerical";
-export type GetKey<Value> = {
-	[Key in Exclude<ValueKey, AutoInferExclude>]: Value extends Values[Key] ? Key : never;
-}[Exclude<ValueKey, AutoInferExclude>] extends infer SpecificKey ? SpecificKey extends never ? {
-	[Key in AutoInferExclude]: Value extends Values[Key] ? Key : never;
-}[AutoInferExclude] : SpecificKey : never;
-export type GetTypes<Value extends unknown[]> = Value extends [
-	infer Type
-] ? Type : Value;
-export type GetType<Value> = GetTypes<UnionToTuple<GetKey<Value>>>;
-export type InferProperty<Value> = Value extends Property ? InferPropertyType<Value["type"]> : never;
-export type InferPropertyType<Value> = Value extends (infer Type)[] ? InferPropertyTypeValue<Type>[] : InferPropertyTypeValue<Value>;
-export type InferPropertyTypeValue<Value> = Value extends PropertyType ? Value extends Schema ? Inferred<Value> : Value extends Schematic<infer Model> ? Model : Value extends ValueKey ? Values[Value] : Value extends (infer NestedElementType)[] ? InferPropertyTypeValue<NestedElementType>[] : Value : never;
-export type InferValue<Value> = Value extends ValueKey ? Values[Value] : Value extends ValueKey[] ? Values[Value[number]] : never;
-export type Inferred<Model extends Schema> = Simplify<{
-	[Key in InferredRequiredProperties<Model>]: Model[Key] extends Property ? InferProperty<Model[Key]> : InferValue<Model[Key]>;
-} & {
-	[Key in InferredOptionalProperties<Model>]?: Model[Key] extends Property ? InferProperty<Model[Key]> : never;
-}>;
-export type InferredOptionalProperties<Model extends Schema> = {
-	[Key in keyof Model]: Model[Key] extends Property ? Model[Key]["required"] extends false ? Key : never : never;
-}[keyof Model];
-export type InferredRequiredProperties<Model extends Schema> = {
-	[Key in keyof Model]: Model[Key] extends Property ? Model[Key]["required"] extends false ? never : Key : Key;
-}[keyof Model];
-export type OptionalProperty<Type> = {
-	required: false;
-	type: GetType<Type>;
-};
-export type Property = {
-	required?: boolean;
-	type: PropertyType | PropertyType[];
-};
-export type PropertyType = Schema | Schematic<unknown> | ValueKey;
-export type RequiredProperty<Type> = {
-	required: true;
-	type: GetType<Type>;
-};
-/**
- * A schema for validating objects
- */
-export type Schema = {
-	[key: string]: Property | ValueKey | ValueKey[];
-};
-/**
- * A schematic for validating objects
- */
-export type Schematic<Model> = {
-	/**
-	 * Does the value match the schema?
-	 */
-	is(value: unknown): value is Model;
-};
-export type Typed = Record<string, unknown>;
-/**
- * A typed schema for validating objects
- */
-export type TypedSchema<Model extends Typed> = Simplify<{
-	[Key in RequiredKeysOf<Model>]: GetType<Model[Key]> | RequiredProperty<Model[Key]>;
-} & {
-	[Key in OptionalKeysOf<Model>]: OptionalProperty<Model[Key]>;
-}>;
-export type ValueKey = keyof Values;
-export type Values = {
-	array: unknown[];
-	bigint: bigint;
-	boolean: boolean;
-	date: Date;
-	"date-like": number | string | Date;
-	function: Function;
-	null: null;
-	number: number;
-	numerical: bigint | number;
-	object: object;
-	string: string;
-	symbol: symbol;
-	undefined: undefined;
-};
-/**
- * Create a schematic from a schema
- */
-export declare function schematic<Model extends Schema>(schema: Model): Schematic<Inferred<Model>>;
-/**
- * Create a schematic from a typed schema
- */
-export declare function schematic<Model extends Typed>(schema: TypedSchema<Model>): Schematic<Model>;
-
-export {};

package/types/is.d.cts

@@ -1,15 +0,0 @@
-// Generated by dts-bundle-generator v9.5.1
-
-/**
- * A schematic for validating objects
- */
-export type Schematic<Model> = {
-	/**
-	 * Does the value match the schema?
-	 */
-	is(value: unknown): value is Model;
-};
-export declare function isDateLike(value: unknown): value is Date;
-export declare function isSchematic(value: unknown): value is Schematic<never>;
-
-export {};