@tstdl/base 0.91.28 → 0.91.30

package/orm/repository.js

@@ -1,11 +1,128 @@
-import { NotImplementedError } from '../errors/not-implemented.error.js';
+/* eslint-disable @typescript-eslint/no-non-null-asserted-optional-chain */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
 import { drizzle } from 'drizzle-orm/node-postgres';
+import { NotFoundError } from '../errors/not-found.error.js';
+import { NotImplementedError } from '../errors/not-implemented.error.js';
+import { NotSupportedError } from '../errors/not-supported.error.js';
+import { Singleton } from '../injector/decorators.js';
+import { inject } from '../injector/inject.js';
+import { injectionToken } from '../injector/token.js';
+import { assertDefinedPass, isUndefined } from '../utils/type-guards.js';
+import { count, eq, inArray, sql, SQL } from 'drizzle-orm';
+import { getDrizzleTableFromType } from './drizzle/schema-converter.js';
 export const repositoryType = Symbol('repositoryType');
-export class EntityRepository {
-    type;
-    database = drizzle(null);
-    async load(_id) {
-        // const result = await this.database.select({ name2: mySchemaUsers.name }).from(mySchemaUsers).leftJoin();
+export const entityType = injectionToken('Entity type');
+let EntityRepository = class EntityRepository {
+    type = inject(entityType);
+    schema = getDrizzleTableFromType('', this.type);
+    database = drizzle('');
+    async load(id) {
+        const entity = await this.tryLoad(id);
+        if (isUndefined(entity)) {
+            throw new NotFoundError(`${this.type.entityName} ${id} not found.`);
+        }
+        return entity;
+    }
+    async tryLoad(id) {
+        return this.tryLoadByQuery(eq(this.schema.id, id));
+    }
+    async loadByQuery(query, options) {
+        const entity = await this.tryLoadByQuery(query, options);
+        if (isUndefined(entity)) {
+            throw new NotFoundError(`${this.type.entityName} not found.`);
+        }
+        return entity;
+    }
+    async tryLoadByQuery(query, options) {
+        if (!(query instanceof SQL)) {
+            throw new NotSupportedError();
+        }
+        const dbQuery = this.database.select()
+            .from(this.schema)
+            .where(query)
+            .offset(options?.offset);
+        const [entity] = (await dbQuery);
+        return entity;
+    }
+    async loadMany(ids, options) {
+        return this.loadManyByQuery(inArray(this.schema.id, ids), options);
+    }
+    async *loadManyCursor(ids, options) {
+        const entities = await this.loadMany(ids, options);
+        yield* entities;
+    }
+    async loadManyByQuery(query, options) {
+        if (!(query instanceof SQL)) {
+            throw new NotSupportedError();
+        }
+        const dbQuery = this.database.select()
+            .from(this.schema)
+            .where(query)
+            .offset(options?.offset)
+            .limit(options?.limit);
+        return dbQuery;
+    }
+    async *loadManyByQueryCursor(query, options) {
+        const entities = await this.loadManyByQuery(query, options);
+        yield* entities;
+    }
+    async loadAll(options) {
+        return this.loadManyByQuery(undefined, options);
+    }
+    async *loadAllCursor(options) {
+        const entities = await this.loadAll(options);
+        yield* entities;
+    }
+    async count() {
+        const dbQuery = this.database
+            .select({ count: count() })
+            .from(this.schema);
+        const [result] = await dbQuery;
+        return assertDefinedPass(result).count;
+    }
+    async countByQuery(query) {
+        if (!(query instanceof SQL)) {
+            throw new NotSupportedError();
+        }
+        const dbQuery = this.database
+            .select({ count: count() })
+            .from(this.schema)
+            .where(query);
+        const [result] = await dbQuery;
+        return assertDefinedPass(result).count;
+    }
+    async has(id) {
+        return this.hasByQuery(eq(this.schema.id, id));
+    }
+    async hasByQuery(query) {
+        // SELECT EXISTS(SELECT 1 FROM contact WHERE id=12) as exists
+        if (!(query instanceof SQL)) {
+            throw new NotSupportedError();
+        }
+        const dbQuery = this.database
+            .select({
+            exists: sql `SELECT EXISTS(SELECT 1 FROM ${this.schema} WHERE ${query})`
+        })
+            .from(this.schema)
+            .where(query);
+        const [result] = await dbQuery;
+        return assertDefinedPass(result).exists;
+    }
+    async hasAll(ids) {
+        const result = await this.database.execute(sql `SELECT array_agg(id) @> ${ids} AS contains FROM ${this.schema};`);
+        return assertDefinedPass(result.rows[0]).contains;
+    }
+    async insert(_entity) {
+        // await this.database.insert(this.schema).values([entity as T]);
         throw new NotImplementedError();
     }
-}
+};
+EntityRepository = __decorate([
+    Singleton()
+], EntityRepository);
+export { EntityRepository };

package/orm/schemas/index.d.ts

@@ -0,0 +1 @@
+export * from './uuid.js';

package/orm/schemas/index.js

@@ -0,0 +1 @@
+export * from './uuid.js';

package/orm/schemas/uuid.d.ts

@@ -0,0 +1,11 @@
+import { StringSchema, type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../../schema/index.js';
+export type UuidSchemaOptions = {
+    defaultRandom?: boolean;
+};
+export declare class UuidSchema extends StringSchema {
+    readonly name = "uuid";
+    readonly defaultRandom: boolean;
+    constructor(options?: UuidSchemaOptions);
+}
+export declare function uuid(options?: UuidSchemaOptions): UuidSchema;
+export declare function Uuid(options?: UuidSchemaOptions & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/orm/schemas/uuid.js

@@ -0,0 +1,16 @@
+import { Property, StringSchema } from '../../schema/index.js';
+const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/u;
+export class UuidSchema extends StringSchema {
+    name = 'uuid';
+    defaultRandom;
+    constructor(options) {
+        super({ pattern: uuidPattern });
+        this.defaultRandom = options?.defaultRandom ?? false;
+    }
+}
+export function uuid(options) {
+    return new UuidSchema(options);
+}
+export function Uuid(options) {
+    return Property(uuid(options), options);
+}

package/orm/types.d.ts

@@ -1,8 +1,21 @@
+import type { HasDefault as DrizzleHasDefault, IsPrimaryKey as DrizzleIsPrimaryKey } from 'drizzle-orm';
+import type { boolean, doublePrecision, integer, PgColumnBuilderBase, text, uuid } from 'drizzle-orm/pg-core';
+import type { GetTagMetadata, Tagged, UnwrapTagged } from 'type-fest';
 import { Integer } from '../schema/index.js';
-import type { doublePrecision, integer, uuid } from 'drizzle-orm/pg-core';
-import type { Tagged } from 'type-fest';
-export declare function Uuid(): PropertyDecorator & MethodDecorator;
-export type Uuid<ColumnName extends string> = Tagged<string, 'column', ReturnType<typeof uuid<ColumnName>>>;
-export type Integer<ColumnName extends string> = Tagged<number, 'column', ReturnType<typeof integer<ColumnName>>>;
-export type DoublePrecision<ColumnName extends string> = Tagged<number, 'column', ReturnType<typeof doublePrecision<ColumnName>>>;
-export { Integer };
+import type { Record } from '../types.js';
+import { Uuid } from './schemas/index.js';
+export type IsPrimaryKey<T> = T extends Tagged<unknown, 'column', PgColumnBuilderBase> ? Tagged<UnwrapTagged<T>, 'column', DrizzleIsPrimaryKey<GetTagMetadata<T, 'column'>>> : Tagged<T, 'column', ColumnBuilder<T>>;
+export type HasDefault<T> = T extends Tagged<unknown, 'column', PgColumnBuilderBase> ? Tagged<UnwrapTagged<T>, 'column', DrizzleHasDefault<GetTagMetadata<T, 'column'>>> : Tagged<T, 'column', ColumnBuilder<T>>;
+export type Nested<T extends Record> = Tagged<T, 'column', {
+    nested: T;
+}>;
+export type ColumnBuilder<T, ColumnName extends string = never> = T extends Tagged<T, 'column', any> ? GetTagMetadata<T, 'column'> : T extends string ? string extends ColumnName ? ReturnType<typeof text<ColumnName, string, [string, ...string[]]>> : ReturnType<typeof text<string, [string, ...string[]]>> : T extends number ? string extends ColumnName ? ReturnType<typeof doublePrecision<ColumnName>> : ReturnType<typeof doublePrecision> : T extends boolean ? string extends ColumnName ? ReturnType<typeof boolean<ColumnName>> : ReturnType<typeof boolean> : never;
+export type TypeBuilder<T, ColumnName extends string = never> = [
+    ColumnName
+] extends [never] ? T extends Tagged<any, 'column', PgColumnBuilderBase> ? T : T extends infer U ? Tagged<U, 'column', ColumnBuilder<U>> : never : never;
+export type Text = Tagged<string, 'column', ReturnType<typeof text<string, [string, ...string[]]>>>;
+export type Uuid = Tagged<string, 'column', ReturnType<typeof uuid>>;
+export type Integer = Tagged<number, 'column', ReturnType<typeof integer>>;
+export type DoublePrecision = Tagged<number, 'column', ReturnType<typeof doublePrecision>>;
+export type Boolean = Tagged<number, 'column', ReturnType<typeof boolean>>;
+export { Integer, Uuid };

package/orm/types.js

@@ -1,6 +1,4 @@
 /* eslint-disable @typescript-eslint/no-redeclare, @typescript-eslint/naming-convention */
-import { createSchemaPropertyDecorator, Integer, string } from '../schema/index.js';
-export function Uuid() {
-    return createSchemaPropertyDecorator({ schema: string() });
-}
-export { Integer };
+import { Integer } from '../schema/index.js';
+import { Uuid } from './schemas/index.js';
+export { Integer, Uuid };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.91.28",
+  "version": "0.91.30",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -56,6 +56,7 @@
     "./json-path": "./json-path/index.js",
     "./jsx": "./jsx/index.js",
     "./key-value-store": "./key-value-store/index.js",
+    "./key-value-store/mongo": "./key-value-store/mongo/index.js",
     "./lock": "./lock/index.js",
     "./lock/mongo": "./lock/mongo/index.js",
     "./lock/web": "./lock/web/index.js",
@@ -125,8 +126,10 @@
     "@types/mjml": "4.7",
     "@types/node": "22",
     "@types/nodemailer": "6.4",
+    "@types/pg": "8.11",
     "@typescript-eslint/eslint-plugin": "7.17",
     "concurrently": "9.0",
+    "drizzle-kit": "0.26",
     "eslint": "8.57",
     "eslint-import-resolver-typescript": "3.6",
     "eslint-plugin-import": "2.31",
@@ -144,14 +147,14 @@
     "@zxcvbn-ts/language-de": "^3.0",
     "@zxcvbn-ts/language-en": "^3.0",
     "chroma-js": "^2.6",
-    "drizzle-orm": "^0.34",
+    "drizzle-orm": "^0.35",
     "handlebars": "^4.7",
     "koa": "^2.15",
     "minio": "^8.0",
     "mjml": "^4.15",
     "mongodb": "^6.9",
     "nodemailer": "^6.9",
-    "pg": "^8.13",
+    "pg": "8.13",
     "playwright": "^1.48",
     "preact": "^10.24",
     "preact-render-to-string": "^6.5",

package/reflection/registry.d.ts

@@ -1,5 +1,5 @@
 import type { AbstractConstructor } from '../types.js';
-import { ReflectionDataMap } from './reflection-data-map.js';
+import { ContextDataMap } from '../data-structures/context-data-map.js';
 import type { DecoratorData } from './types.js';
 export type ReflectionMetadata = TypeMetadata | PropertyMetadata | MethodMetadata | ConstructorParameterMetadata | MethodParameterMetadata;
 export type MetadataType = 'type' | 'property' | 'method' | 'method-parameter' | 'constructor-parameter';
@@ -15,31 +15,34 @@ export type TypeMetadata = MetadataBase<'type'> & {
     readonly staticProperties: ReadonlyMap<string | symbol, PropertyMetadata>;
     readonly methods: ReadonlyMap<string | symbol, MethodMetadata>;
     readonly staticMethods: ReadonlyMap<string | symbol, MethodMetadata>;
-    readonly data: ReflectionDataMap;
+    readonly data: ContextDataMap;
 };
 export type PropertyMetadata = MetadataBase<'property'> & {
     key: string | symbol;
     type: AbstractConstructor;
     isAccessor: boolean;
-    data: ReflectionDataMap;
+    data: ContextDataMap;
+    inherited: boolean;
 };
 export type MethodMetadata = MetadataBase<'method'> & {
     parameters: MethodParameterMetadata[];
     returnType: AbstractConstructor | undefined;
-    data: ReflectionDataMap;
+    data: ContextDataMap;
+    inherited: boolean;
 };
 export type ConstructorParameterMetadata = MetadataBase<'constructor-parameter'> & {
     type: AbstractConstructor | undefined;
     index: number;
-    data: ReflectionDataMap;
+    data: ContextDataMap;
 };
 export type MethodParameterMetadata = MetadataBase<'method-parameter'> & {
     type: AbstractConstructor;
     index: number;
-    data: ReflectionDataMap;
+    data: ContextDataMap;
 };
 export type ParameterMetadata = ConstructorParameterMetadata | MethodParameterMetadata;
 export declare class ReflectionRegistry {
+    #private;
     private readonly metadataMap;
     private readonly finalizedTypesSet;
     constructor();

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/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/number.d.ts

@@ -5,6 +5,7 @@ export type NumberSchemaOptions = SimpleSchemaOptions & {
 };
 export declare class NumberSchema extends SimpleSchema<number> {
     readonly name = "number";
+    readonly integer: boolean;
     constructor(options?: NumberSchemaOptions);
 }
 export declare function number(options?: NumberSchemaOptions): NumberSchema;

package/schema/schemas/number.js

@@ -4,6 +4,7 @@ import { SchemaError } from '../schema.error.js';
 import { SimpleSchema } from './simple.js';
 export class NumberSchema extends SimpleSchema {
     name = 'number';
+    integer;
     constructor(options) {
         super('number', isNumber, options, {
             coercers: {
@@ -20,6 +21,7 @@ export class NumberSchema extends SimpleSchema {
                 (options?.integer == true) ? (value) => globalThis.Number.isInteger(value) ? ({ success: true }) : ({ success: false, error: 'value is not an integer.' }) : null
             ]
         });
+        this.integer = options?.integer ?? false;
     }
 }
 export function number(options) {

package/schema/schemas/string.d.ts

@@ -4,7 +4,7 @@ export type StringSchemaOptions = SimpleSchemaOptions & {
     pattern?: RegExp | string;
 };
 export declare class StringSchema extends SimpleSchema<string> {
-    readonly name = "string";
+    readonly name: string;
     constructor(options?: StringSchemaOptions);
 }
 export declare function string(options?: StringSchemaOptions): StringSchema;

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();
+}

package/orm/schema-converter.d.ts

@@ -1,99 +0,0 @@
-import { boolean, doublePrecision, text, type PgTableWithColumns } from 'drizzle-orm/pg-core';
-import type { GetTagMetadata, SnakeCase, Tagged } from 'type-fest';
-import type { Type } from '../types.js';
-import { BuildColumns, NotNull } from 'drizzle-orm';
-import type { DbSchemaStatic } from './schema.js';
-import { Integer } from './types.js';
-export declare const mySchema: import("drizzle-orm/pg-core").PgSchema<"my_schema">;
-export declare const colors: import("drizzle-orm/pg-core").PgEnum<["red", "green", "blue"]>;
-export declare const mySchemaUsers: PgTableWithColumns<{
-    name: "users";
-    schema: "my_schema";
-    columns: {
-        id: import("drizzle-orm/pg-core").PgColumn<{
-            name: "id";
-            tableName: "users";
-            dataType: "string";
-            columnType: "PgUUID";
-            data: string;
-            driverParam: string;
-            notNull: false;
-            hasDefault: false;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: undefined;
-            baseColumn: never;
-            generated: undefined;
-        }, {}, {}>;
-        name: import("drizzle-orm/pg-core").PgColumn<{
-            name: "name";
-            tableName: "users";
-            dataType: "string";
-            columnType: "PgText";
-            data: string;
-            driverParam: string;
-            notNull: false;
-            hasDefault: false;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
-            baseColumn: never;
-            generated: undefined;
-        }, {}, {}>;
-        age: import("drizzle-orm/pg-core").PgColumn<{
-            name: "age";
-            tableName: "users";
-            dataType: "number";
-            columnType: "PgInteger";
-            data: number;
-            driverParam: string | number;
-            notNull: false;
-            hasDefault: false;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: undefined;
-            baseColumn: never;
-            generated: undefined;
-        }, {}, {}>;
-        color: import("drizzle-orm/pg-core").PgColumn<{
-            name: "color";
-            tableName: "users";
-            dataType: "string";
-            columnType: "PgEnumColumn";
-            data: "red" | "green" | "blue";
-            driverParam: string;
-            notNull: false;
-            hasDefault: true;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: ["red", "green", "blue"];
-            baseColumn: never;
-            generated: undefined;
-        }, {}, {}>;
-    };
-    dialect: "pg";
-}>;
-type ColumnBase<Name extends string, T> = T extends Tagged<T, 'column', any> ? GetTagMetadata<T, 'column'> : T extends string ? ReturnType<typeof text<Name, string, [string, ...string[]]>> : T extends number ? ReturnType<typeof doublePrecision<Name>> : T extends boolean ? ReturnType<typeof boolean<Name>> : never;
-type Column<Name extends string, T> = null extends T ? ColumnBase<Name, T> : NotNull<ColumnBase<Name, T>>;
-export declare function getDrizzleSchemaFromType<T extends Type & DbSchemaStatic>(type: T): PgTableWithColumns<{
-    name: SnakeCase<T['entityName']>;
-    schema: '';
-    columns: BuildColumns<T['entityName'], {
-        [P in keyof InstanceType<T>]: Column<Extract<P, string>, InstanceType<T>[P]>;
-    }, 'pg'>;
-    dialect: '';
-}>;
-export declare class Entity2 {
-    id: string;
-}
-export declare class User extends Entity2 {
-    static entityName: 'UserData';
-    name: string;
-    age: Integer<'age'> | null;
-    hasAge: boolean;
-}
-export {};