@tstdl/base 0.91.28 → 0.91.31

package/reflection/registry.js

@@ -1,9 +1,9 @@
 import { FactoryMap } from '../utils/factory-map.js';
 import { lazyObject, lazyObjectValue } from '../utils/object/lazy-property.js';
 import { getDesignType, getParameterTypes, getReturnType } from '../utils/reflection.js';
-import { isDefined, isUndefined } from '../utils/type-guards.js';
+import { isDefined, isNotNull, isUndefined } from '../utils/type-guards.js';
+import { ContextDataMap } from '../data-structures/context-data-map.js';
 import { getDecoratorData } from './decorator-data.js';
-import { ReflectionDataMap } from './reflection-data-map.js';
 export class ReflectionRegistry {
     metadataMap;
     finalizedTypesSet;
@@ -17,11 +17,7 @@ export class ReflectionRegistry {
     getMetadata(type) {
         const metadata = this.metadataMap.get(type);
         if (isDefined(metadata) && !this.finalizedTypesSet.has(type)) {
-            metadata.properties = new Map(metadata.properties);
-            metadata.staticProperties = new Map(metadata.staticProperties);
-            metadata.methods = new Map(metadata.methods);
-            metadata.staticMethods = new Map(metadata.staticMethods);
-            this.finalizedTypesSet.add(type);
+            this.#finalizeMetadata(metadata);
         }
         return metadata;
     }
@@ -73,23 +69,38 @@ export class ReflectionRegistry {
         }
         return this.metadataMap.get(type);
     }
+    #finalizeMetadata(metadata) {
+        const parentMetadata = isNotNull(metadata.parent) ? reflectionRegistry.getMetadata(metadata.parent) : undefined;
+        metadata.properties = new Map([...getInheritedMetadataEntries(parentMetadata?.properties), ...metadata.properties]);
+        metadata.staticProperties = new Map([...getInheritedMetadataEntries(parentMetadata?.staticProperties), ...metadata.staticProperties]);
+        metadata.methods = new Map([...getInheritedMetadataEntries(parentMetadata?.methods), ...metadata.methods]);
+        metadata.staticMethods = new Map([...getInheritedMetadataEntries(parentMetadata?.staticMethods), ...metadata.staticMethods]);
+        this.finalizedTypesSet.add(metadata.constructor);
+    }
+}
+function getInheritedMetadataEntries(metadata) {
+    return [...(metadata ?? [])].map(([key, value]) => [key, toInheritedMetadata(value)]);
+}
+function toInheritedMetadata(metadata) {
+    return { ...metadata, inherited: true };
 }
 function initializeType(type) {
+    const parent = Reflect.getPrototypeOf(type);
     return lazyObject({
         metadataType: 'type',
         constructor: lazyObjectValue(type),
-        parent: lazyObjectValue(Reflect.getPrototypeOf(type)),
+        parent: lazyObjectValue(parent),
         parameters: {
             initializer() {
                 const parametersTypes = getParameterTypes(type);
-                return parametersTypes?.map((parameterType, index) => ({ metadataType: 'constructor-parameter', index, type: parameterType, data: new ReflectionDataMap() }));
+                return parametersTypes?.map((parameterType, index) => ({ metadataType: 'constructor-parameter', index, type: parameterType, data: new ContextDataMap() }));
             }
         },
         properties: {
-            initializer: () => new FactoryMap((key) => ({ metadataType: 'property', key, type: getDesignType(type.prototype, key), isAccessor: false, data: new ReflectionDataMap() }))
+            initializer: () => new FactoryMap((key) => ({ metadataType: 'property', key, type: getDesignType(type.prototype, key), isAccessor: false, data: new ContextDataMap(), inherited: false }))
         },
         staticProperties: {
-            initializer: () => new FactoryMap((key) => ({ metadataType: 'property', key, type: getDesignType(type, key), isAccessor: false, data: new ReflectionDataMap() }))
+            initializer: () => new FactoryMap((key) => ({ metadataType: 'property', key, type: getDesignType(type, key), isAccessor: false, data: new ContextDataMap(), inherited: false }))
         },
         methods: {
             initializer: () => new FactoryMap((key) => {
@@ -98,7 +109,7 @@ function initializeType(type) {
                 if (isUndefined(parameters)) {
                     throw new Error(`Could not get parameters for method ${key.toString()} of type ${type.name}`);
                 }
-                return { metadataType: 'method', parameters: parameters.map((parameter, index) => ({ metadataType: 'method-parameter', index, type: parameter, data: new ReflectionDataMap() })), returnType, data: new ReflectionDataMap() };
+                return { metadataType: 'method', parameters: parameters.map((parameter, index) => ({ metadataType: 'method-parameter', index, type: parameter, data: new ContextDataMap() })), returnType, data: new ContextDataMap(), inherited: false };
             })
         },
         staticMethods: {
@@ -108,10 +119,10 @@ function initializeType(type) {
                 if (isUndefined(parameters)) {
                     throw new Error(`Could not get parameters for static method ${key.toString()} of type ${type.name}`);
                 }
-                return { metadataType: 'method', parameters: parameters.map((parameter, index) => ({ metadataType: 'method-parameter', index, type: parameter, data: new ReflectionDataMap() })), returnType, data: new ReflectionDataMap() };
+                return { metadataType: 'method', parameters: parameters.map((parameter, index) => ({ metadataType: 'method-parameter', index, type: parameter, data: new ContextDataMap() })), returnType, data: new ContextDataMap(), inherited: false };
             })
         },
-        data: { initializer: () => new ReflectionDataMap() }
+        data: { initializer: () => new ContextDataMap() }
     });
 }
 export const reflectionRegistry = new ReflectionRegistry();

package/schema/decorators/property.d.ts

@@ -3,5 +3,5 @@ import type { TypedOmit } from '../../types.js';
 import type { SchemaTestable } from '../schema.js';
 import type { SchemaPropertyReflectionData } from './types.js';
 export type SchemaPropertyDecoratorOptions = TypedOmit<SchemaPropertyReflectionData, 'schema'>;
-export declare function Property(schema?: SchemaTestable, options?: SchemaPropertyDecoratorOptions): Decorator<'property' | 'accessor'>;
-export declare function Property(options?: SchemaPropertyDecoratorOptions): Decorator<'property' | 'accessor'>;
+export declare function Property(schema: SchemaTestable, options?: SchemaPropertyDecoratorOptions): Decorator<'property' | 'accessor'>;
+export declare function Property(options: SchemaPropertyDecoratorOptions): Decorator<'property' | 'accessor'>;

package/schema/decorators/types.d.ts

@@ -11,4 +11,5 @@ export type SchemaPropertyReflectionData = {
     array?: boolean;
     optional?: boolean;
     nullable?: boolean;
+    data?: Record<PropertyKey, any>;
 };

package/schema/schema.d.ts

@@ -23,8 +23,8 @@ export type SchemaTestable<T = unknown> = Schema<T> | AbstractConstructor<T> | N
 export type SchemaOutput<T extends SchemaTestable> = T extends SchemaTestable<infer U> ? U : never;
 export declare const OPTIONAL: unique symbol;
 export declare abstract class Schema<T = unknown> {
-    abstract readonly name: string;
     readonly [OPTIONAL]: boolean;
+    abstract readonly name: string;
     /**
      * Test an unknown value to see whether it corresponds to the schema.
      * @param schema schema to test against

package/schema/schemas/array.d.ts

@@ -2,11 +2,14 @@ import type { JsonPath } from '../../json-path/json-path.js';
 import type { TypedOmit } from '../../types.js';
 import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
 import { Schema, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+import type { Coercible } from '../types.js';
+export type ArraySchemaOptions = Coercible;
 export declare class ArraySchema<T> extends Schema<T[]> {
+    #private;
     readonly name: string;
     readonly itemSchema: Schema<T>;
-    constructor(itemSchema: SchemaTestable<T>);
+    constructor(itemSchema: SchemaTestable<T>, options?: ArraySchemaOptions);
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T[]>;
 }
-export declare function array<T>(schema: SchemaTestable<T>): ArraySchema<T>;
-export declare function Array(schema: SchemaTestable, options?: TypedOmit<SchemaPropertyDecoratorOptions, 'array'>): SchemaPropertyDecorator;
+export declare function array<T>(schema: SchemaTestable<T>, options?: ArraySchemaOptions): ArraySchema<T>;
+export declare function Array(schema: SchemaTestable, options?: ArraySchemaOptions & TypedOmit<SchemaPropertyDecoratorOptions, 'array'>): SchemaPropertyDecorator;

package/schema/schemas/array.js

@@ -5,15 +5,20 @@ import { Property } from '../decorators/index.js';
 import { Schema } from '../schema.js';
 import { schemaTestableToSchema } from '../testable.js';
 export class ArraySchema extends Schema {
+    #options;
     name;
     itemSchema;
-    constructor(itemSchema) {
+    constructor(itemSchema, options = {}) {
         super();
+        this.#options = options;
         this.itemSchema = schemaTestableToSchema(itemSchema);
         this.name = `Array[${this.itemSchema.name}]`;
     }
     _test(value, path, options) {
         if (!isArray(value)) {
+            if ((this.#options.coerce ?? options.coerce) == true) {
+                return this._test([value], path, options);
+            }
             return { valid: false, error: SchemaError.expectedButGot('array', typeOf(value), path) };
         }
         const values = [];
@@ -27,9 +32,9 @@ export class ArraySchema extends Schema {
         return { valid: true, value: values };
     }
 }
-export function array(schema) {
-    return new ArraySchema(schema);
+export function array(schema, options) {
+    return new ArraySchema(schema, options);
 }
 export function Array(schema, options) {
-    return Property(schema, { ...options, array: true });
+    return Property(array(schema, options), options);
 }

package/schema/schemas/deferred.d.ts

@@ -0,0 +1,12 @@
+import type { JsonPath } from '../../json-path/json-path.js';
+import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { Schema, type SchemaOutput, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+export declare class DeferredSchema<T extends SchemaTestable> extends Schema<SchemaOutput<T>> {
+    readonly name: string;
+    readonly testable: T;
+    readonly schema: Schema<SchemaOutput<T>>;
+    constructor(schema: () => T);
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<SchemaOutput<T>>;
+}
+export declare function deferred<T extends SchemaTestable>(schema: () => T): DeferredSchema<T>;
+export declare function Deferred<T extends SchemaTestable>(schema: () => T, options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/deferred.js

@@ -0,0 +1,23 @@
+import { lazyProperty } from '../../utils/object/lazy-property.js';
+import { Property } from '../decorators/index.js';
+import { Schema } from '../schema.js';
+import { schemaTestableToSchema } from '../testable.js';
+export class DeferredSchema extends Schema {
+    name;
+    testable;
+    schema;
+    constructor(schema) {
+        super();
+        lazyProperty(this, 'schema', () => schemaTestableToSchema(schema()));
+        lazyProperty(this, 'name', () => `Deferred[${this.schema.name}]`);
+    }
+    _test(value, path, options) {
+        return this.schema._test(value, path, options);
+    }
+}
+export function deferred(schema) {
+    return new DeferredSchema(schema);
+}
+export function Deferred(schema, options) {
+    return Property(deferred(schema), options);
+}

package/schema/schemas/index.d.ts

@@ -4,6 +4,7 @@ export * from './bigint.js';
 export * from './boolean.js';
 export * from './date.js';
 export * from './defaulted.js';
+export * from './deferred.js';
 export * from './enumeration.js';
 export * from './function.js';
 export * from './instance.js';

package/schema/schemas/index.js

@@ -4,6 +4,7 @@ export * from './bigint.js';
 export * from './boolean.js';
 export * from './date.js';
 export * from './defaulted.js';
+export * from './deferred.js';
 export * from './enumeration.js';
 export * from './function.js';
 export * from './instance.js';

package/schema/schemas/number.d.ts

@@ -2,9 +2,14 @@ import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } fro
 import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
 export type NumberSchemaOptions = SimpleSchemaOptions & {
     integer?: boolean;
+    minimum?: number;
+    maximum?: number;
 };
 export declare class NumberSchema extends SimpleSchema<number> {
     readonly name = "number";
+    readonly integer: boolean;
+    readonly minimum: number | null;
+    readonly maximum: number | null;
     constructor(options?: NumberSchemaOptions);
 }
 export declare function number(options?: NumberSchemaOptions): NumberSchema;

package/schema/schemas/number.js

@@ -4,6 +4,9 @@ import { SchemaError } from '../schema.error.js';
 import { SimpleSchema } from './simple.js';
 export class NumberSchema extends SimpleSchema {
     name = 'number';
+    integer;
+    minimum;
+    maximum;
     constructor(options) {
         super('number', isNumber, options, {
             coercers: {
@@ -17,9 +20,13 @@ export class NumberSchema extends SimpleSchema {
                 bigint: (value) => ({ success: true, value: globalThis.Number(value), valid: false })
             },
             constraints: [
-                (options?.integer == true) ? (value) => globalThis.Number.isInteger(value) ? ({ success: true }) : ({ success: false, error: 'value is not an integer.' }) : null
+                (options?.integer == true) ? (value) => globalThis.Number.isInteger(value) ? ({ success: true }) : ({ success: false, error: 'Value is not an integer.' }) : null,
+                isNumber(options?.minimum) ? (value) => (value >= this.minimum) ? ({ success: true }) : ({ success: false, error: `Value must be more than or equal to ${this.minimum}.` }) : null,
+                isNumber(options?.maximum) ? (value) => (value >= this.maximum) ? ({ success: true }) : ({ success: false, error: `Value must be less than or equal to ${this.maximum}.` }) : null
             ]
         });
+        this.integer = options?.integer ?? false;
+        this.minimum = options?.minimum ?? null;
     }
 }
 export function number(options) {

package/schema/schemas/string.d.ts

@@ -2,9 +2,12 @@ import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } fro
 import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
 export type StringSchemaOptions = SimpleSchemaOptions & {
     pattern?: RegExp | string;
+    lowercase?: boolean;
 };
 export declare class StringSchema extends SimpleSchema<string> {
-    readonly name = "string";
+    readonly name: string;
+    readonly pattern: RegExp | null;
+    readonly lowercase: boolean;
     constructor(options?: StringSchemaOptions);
 }
 export declare function string(options?: StringSchemaOptions): StringSchema;

package/schema/schemas/string.js

@@ -3,8 +3,9 @@ import { Property } from '../decorators/index.js';
 import { SimpleSchema } from './simple.js';
 export class StringSchema extends SimpleSchema {
     name = 'string';
+    pattern;
+    lowercase;
     constructor(options) {
-        const pattern = isDefined(options?.pattern) ? isString(options.pattern) ? RegExp(options.pattern, 'u') : isRegExp(options.pattern) ? options.pattern : undefined : undefined;
         super('string', isString, options, {
             coercers: {
                 number: (value) => ({ success: true, value: globalThis.String(value), valid: true }),
@@ -12,9 +13,14 @@ export class StringSchema extends SimpleSchema {
                 bigint: (value) => ({ success: true, value: globalThis.String(value), valid: true })
             },
             constraints: [
-                isDefined(pattern) ? ((value) => pattern.test(value) ? ({ success: true }) : ({ success: false, error: 'Value did not match pattern.' })) : null
+                isDefined(options?.pattern) ? ((value) => this.pattern.test(value) ? ({ success: true }) : ({ success: false, error: 'Value did not match pattern.' })) : null
             ]
         });
+        this.pattern = isString(options?.pattern)
+            ? RegExp(options.pattern, 'u')
+            : isRegExp(options?.pattern)
+                ? options.pattern
+                : null;
     }
 }
 export function string(options) {

package/schema/schemas/uint8-array.d.ts

@@ -8,8 +8,9 @@ export type Uint8ArraySchemaOptions = SimpleSchemaOptions & {
 };
 export declare class Uint8ArraySchema extends SimpleSchema<Uint8Array> {
     readonly name = "Uint8Array";
-    readonly options: Uint8ArraySchemaOptions;
+    readonly minimumLength: number | null;
+    readonly maximumLength: number | null;
     constructor(options?: Uint8ArraySchemaOptions);
 }
 export declare function uint8Array(options?: Uint8ArraySchemaOptions): Uint8ArraySchema;
-export declare function Uint8ArrayProperty(schemaOptions?: Uint8ArraySchemaOptions, options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+export declare function Uint8ArrayProperty(options?: Uint8ArraySchemaOptions & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/uint8-array.js

@@ -3,19 +3,22 @@ import { Property } from '../decorators/index.js';
 import { SimpleSchema } from './simple.js';
 export class Uint8ArraySchema extends SimpleSchema {
     name = 'Uint8Array';
-    options;
+    minimumLength;
+    maximumLength;
     constructor(options) {
         super('Uint8Array', isUint8Array, options, {
             constraints: [
-                isDefined(options?.minimumLength) ? (value) => (value.byteLength >= options.minimumLength) ? ({ success: true }) : ({ success: false, error: `Size must be at least ${options.minimumLength} bytes.` }) : null,
-                isDefined(options?.maximumLength) ? (value) => (value.byteLength <= options.maximumLength) ? ({ success: true }) : ({ success: false, error: `Size must be at most ${options.maximumLength} bytes.` }) : null
+                isDefined(options?.minimumLength) ? (value) => (value.byteLength >= this.minimumLength) ? ({ success: true }) : ({ success: false, error: `Size must be at least ${this.minimumLength} bytes.` }) : null,
+                isDefined(options?.maximumLength) ? (value) => (value.byteLength <= this.maximumLength) ? ({ success: true }) : ({ success: false, error: `Size must be at most ${this.maximumLength} bytes.` }) : null
             ]
         });
+        this.minimumLength = options?.minimumLength ?? null;
+        this.maximumLength = options?.maximumLength ?? null;
     }
 }
 export function uint8Array(options) {
     return new Uint8ArraySchema(options);
 }
-export function Uint8ArrayProperty(schemaOptions, options) {
-    return Property(uint8Array(schemaOptions), options);
+export function Uint8ArrayProperty(options) {
+    return Property(uint8Array(options), options);
 }

package/templates/resolvers/file.template-resolver.d.ts

@@ -1,5 +1,4 @@
-import type { Resolvable } from '../../injector/interfaces.js';
-import { resolveArgumentType } from '../../injector/interfaces.js';
+import { Resolvable, resolveArgumentType } from '../../injector/interfaces.js';
 import type { TypedOmit } from '../../types.js';
 import { TemplateField } from '../template.model.js';
 import type { TemplateRenderer, TemplateRendererOptions, TemplateRendererString } from '../template.renderer.js';

package/templates/resolvers/file.template-resolver.js

@@ -14,7 +14,7 @@ import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { BadRequestError } from '../../errors/bad-request.error.js';
 import { InjectArg, Singleton } from '../../injector/decorators.js';
-import { Property } from '../../schema/index.js';
+import { StringProperty } from '../../schema/index.js';
 import { TemplateField } from '../template.model.js';
 import { TemplateResolver } from '../template.resolver.js';
 export const fileTemplateProviderConfig = {};
@@ -22,7 +22,7 @@ export class FileTemplateField extends TemplateField {
     templateFile;
 }
 __decorate([
-    Property(),
+    StringProperty(),
     __metadata("design:type", String)
 ], FileTemplateField.prototype, "templateFile", void 0);
 let FileTemplateResolver = class FileTemplateResolver extends TemplateResolver {

package/templates/resolvers/jsx.template-resolver.d.ts

@@ -1,7 +1,6 @@
 import type { PartialProperty, Record, TypedOmit } from '../../types.js';
 import type { ComponentClass, FunctionComponent } from 'preact';
-import type { Template } from '../template.model.js';
-import { TemplateField } from '../template.model.js';
+import { Template, TemplateField } from '../template.model.js';
 import type { TemplateRenderer, TemplateRendererOptions, TemplateRendererString } from '../template.renderer.js';
 import { TemplateResolver } from '../template.resolver.js';
 export type JsxTemplate<Context extends Record = any> = FunctionComponent<Context> | ComponentClass<Context, any>;
@@ -9,7 +8,6 @@ export declare class JsxTemplateField<Renderer extends string = string, Options
     template: JsxTemplate<Context>;
 }
 export declare class JsxTemplateResolver extends TemplateResolver<JsxTemplateField, JsxTemplate> {
-    constructor();
     canHandle(resolver: string): boolean;
     resolve(field: JsxTemplateField): JsxTemplate;
 }

package/templates/resolvers/jsx.template-resolver.js

@@ -8,20 +8,17 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { Singleton } from '../../injector/decorators.js';
-import { Property } from '../../schema/index.js';
+import { FunctionProperty } from '../../schema/index.js';
 import { TemplateField, simpleTemplate } from '../template.model.js';
 import { TemplateResolver } from '../template.resolver.js';
 export class JsxTemplateField extends TemplateField {
     template;
 }
 __decorate([
-    Property(),
+    FunctionProperty(),
     __metadata("design:type", Object)
 ], JsxTemplateField.prototype, "template", void 0);
 let JsxTemplateResolver = class JsxTemplateResolver extends TemplateResolver {
-    constructor() {
-        super();
-    }
     canHandle(resolver) {
         return (resolver == 'jsx');
     }
@@ -30,8 +27,7 @@ let JsxTemplateResolver = class JsxTemplateResolver extends TemplateResolver {
     }
 };
 JsxTemplateResolver = __decorate([
-    Singleton(),
-    __metadata("design:paramtypes", [])
+    Singleton()
 ], JsxTemplateResolver);
 export { JsxTemplateResolver };
 export function jsxTemplateField(field) {

package/templates/template.model.d.ts

@@ -14,7 +14,7 @@ export type TemplateFields<Fields extends Record<string, boolean>, Resolver exte
 }>;
 export declare abstract class Template<Fields extends Record<string, boolean> = Record<string, boolean>, TemplateOptions = any, Context extends Record = any> {
     readonly [templateContext]?: (context: Context) => void;
-    /** name of template */
+    /** Name of template */
     name: string;
     fields: TemplateFields<Fields, string, string, any, Context>;
     options?: TemplateOptions;

package/templates/template.model.js

@@ -7,18 +7,18 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { Any, any, Class, object, Optional, Property } from '../schema/index.js';
+import { Any, any, Class, object, Optional, Property, StringProperty } from '../schema/index.js';
 let TemplateField = class TemplateField {
     resolver;
     renderer;
     options;
 };
 __decorate([
-    Property(),
+    StringProperty(),
     __metadata("design:type", String)
 ], TemplateField.prototype, "resolver", void 0);
 __decorate([
-    Property(),
+    StringProperty(),
     __metadata("design:type", String)
 ], TemplateField.prototype, "renderer", void 0);
 __decorate([
@@ -31,13 +31,13 @@ TemplateField = __decorate([
 ], TemplateField);
 export { TemplateField };
 export class Template {
-    /** name of template */
+    /** Name of template */
     name;
     fields;
     options;
 }
 __decorate([
-    Property(),
+    StringProperty(),
     __metadata("design:type", String)
 ], Template.prototype, "name", void 0);
 __decorate([

package/utils/math.d.ts

@@ -1,4 +1,4 @@
-import type { RandomNumberGeneratorFn } from '../random/number-generator/random-number-generator-function.js';
+import { type RandomNumberGeneratorFn } from '../random/number-generator/random-number-generator-function.js';
 /**
  * Generate a random float in interval [min, max).
  * @param min minimum value
@@ -81,3 +81,13 @@ export declare function clamp(value: number, minimum: number, maximum: number):
  * @returns nth-root of base
  */
 export declare function nthRoot(base: number, root: number): number;
+/**
+ *
+ * @param t Time in interval [0, 1]
+ * @param attenuationExponentStart Sensible values are between 1 (linear attenuation) and ~10 (no attenuation until t = ~0.9, then sharply increasing attenuation)
+ * @param attenuationExponentEnd Sensible values are between 1 (linear attenuation) and ~10 (no attenuation until t = ~0.9, then sharply increasing attenuation)
+ * @param deadzoneWidthStart Deadzone width to add in front of 0.5. Sensible values are between 0 and 0.5
+ * @param deadzoneWidthEnd Deadzone width to add to interval [0.5, 1]. Sensible values are between 0 and 0.5
+ * @returns Coefficient in interval [0, 1]
+ */
+export declare function getAttenuationCoefficient(t: number, attenuationExponentStart: number | null, attenuationExponentEnd: number | null, deadzoneWidthStart?: number, deadzoneWidthEnd?: number): number;

package/utils/math.js

@@ -1,5 +1,6 @@
 import { NotSupportedError } from '../errors/not-supported.error.js';
 import { defaultRandomNumberGeneratorFn } from '../random/number-generator/random-number-generator-function.js';
+import { isNull } from './type-guards.js';
 /**
  * Generate a random float in interval [min, max).
  * @param min minimum value
@@ -111,3 +112,30 @@ export function clamp(value, minimum, maximum) {
 export function nthRoot(base, root) {
     return (base < 0) ? -((-base) ** (1 / root)) : (base ** (1 / root));
 }
+/**
+ *
+ * @param t Time in interval [0, 1]
+ * @param attenuationExponentStart Sensible values are between 1 (linear attenuation) and ~10 (no attenuation until t = ~0.9, then sharply increasing attenuation)
+ * @param attenuationExponentEnd Sensible values are between 1 (linear attenuation) and ~10 (no attenuation until t = ~0.9, then sharply increasing attenuation)
+ * @param deadzoneWidthStart Deadzone width to add in front of 0.5. Sensible values are between 0 and 0.5
+ * @param deadzoneWidthEnd Deadzone width to add to interval [0.5, 1]. Sensible values are between 0 and 0.5
+ * @returns Coefficient in interval [0, 1]
+ */
+export function getAttenuationCoefficient(t, attenuationExponentStart, attenuationExponentEnd, deadzoneWidthStart = 0, deadzoneWidthEnd = 0) {
+    if ((t < 0) || (t > 1)) {
+        return 0;
+    }
+    if (t <= 0.5) {
+        if (isNull(attenuationExponentStart)) {
+            return 1;
+        }
+        if (t >= (0.5 - deadzoneWidthStart)) {
+            return 1;
+        }
+        return 1 - (-2 * (t - (0.5 - deadzoneWidthStart)) * (0.5 / (0.5 - deadzoneWidthStart))) ** (attenuationExponentStart ** 1.5);
+    }
+    if (isNull(attenuationExponentEnd) || (t <= (0.5 + deadzoneWidthEnd))) {
+        return 1;
+    }
+    return 1 - (-2 * (-(t - 1) - (0.5 - deadzoneWidthEnd)) * (0.5 / (0.5 - deadzoneWidthEnd))) ** (attenuationExponentEnd ** 1.5);
+}

package/utils/string/index.d.ts

@@ -1,3 +1,4 @@
 export * from './hypenate.js';
+export * from './snake-case.js';
 export * from './title-case.js';
 export * from './trim.js';

package/utils/string/index.js

@@ -1,3 +1,4 @@
 export * from './hypenate.js';
+export * from './snake-case.js';
 export * from './title-case.js';
 export * from './trim.js';

package/utils/string/snake-case.d.ts

@@ -0,0 +1 @@
+export declare function toSnakeCase(value: string): string;

package/utils/string/snake-case.js

@@ -0,0 +1,4 @@
+const pattern = /(?=[A-Z])/u; // eslint-disable-line prefer-named-capture-group
+export function toSnakeCase(value) {
+    return value.split(pattern).join('_').toLowerCase();
+}