@tstdl/base 0.92.43 → 0.92.47

package/orm/server/drizzle/schema-converter.d.ts

@@ -3,10 +3,11 @@ import { type PgColumnBuilder, type PgEnum, type PgSchema, type PgTableWithColum
 import type { CamelCase, ConditionalPick, SnakeCase } from 'type-fest';
 import { JsonPath } from '../../../json-path/json-path.js';
 import { type Record } from '../../../schema/index.js';
-import type { AbstractConstructor, Enumeration } from '../../../types.js';
+import type { AbstractConstructor, Enumeration, UnionToIntersection } from '../../../types.js';
+import type { Tagged } from '../../../types/index.js';
 import type { OrmColumnReflectionData } from '../../decorators.js';
 import type { EntityType } from '../../entity.js';
-import type { ColumnBuilder, embedded } from '../../types.js';
+import type { ColumnBuilder, EmbeddedConfigTag } from '../../types.js';
 type Column<Name extends string, T> = null extends T ? ColumnBuilder<T, Name> : NotNull<ColumnBuilder<T, Name>>;
 type ConverterContext = {
     type: AbstractConstructor;
@@ -20,24 +21,22 @@ export type ColumnDefinition = {
     dereferenceObjectPath: (obj: Record) => any;
 };
 export declare const getDrizzleTableFromType: typeof _getDrizzleTableFromType;
-export type ColumnPrefix<T> = T extends {
+export type ColumnPrefix<T> = T extends Tagged<unknown, EmbeddedConfigTag, {
     prefix: infer Prefix;
-} ? Prefix extends string ? Prefix : '' : '';
+}> ? Prefix extends string ? Prefix : '' : '';
 export type PgTableFromType<S extends string, T extends AbstractConstructor, TableName extends string = T extends Required<EntityType> ? SnakeCase<T['entityName']> : string> = PgTableWithColumns<{
     name: TableName;
     schema: S;
     columns: BuildColumns<TableName, {
         [P in Exclude<keyof InstanceType<T>, keyof EmbeddedProperties<InstanceType<T>>>]: Column<CamelCase<Extract<P, string>>, InstanceType<T>[P]>;
-    } & {
+    } & UnionToIntersection<{
         [P in keyof EmbeddedProperties<InstanceType<T>>]: EmbeddedColumns<InstanceType<T>[P], ColumnPrefix<InstanceType<T>[P]>>;
-    }[keyof EmbeddedProperties<InstanceType<T>>], 'pg'>;
+    }[keyof EmbeddedProperties<InstanceType<T>>]>, 'pg'>;
     dialect: 'pg';
 }>;
-export type EmbeddedProperties<T> = ConditionalPick<T, {
-    [embedded]: {
-        prefix: any;
-    };
-}>;
+export type EmbeddedProperties<T> = ConditionalPick<T, Tagged<unknown, EmbeddedConfigTag, {
+    prefix: any;
+}>>;
 export type EmbeddedColumns<T, Prefix extends string> = {
     [P in keyof T as CamelCase<`${Prefix}${Extract<P, string>}`>]: Column<CamelCase<`${Prefix}${Extract<P, string>}`>, T[P]>;
 };

package/orm/server/drizzle/schema-converter.js

@@ -46,7 +46,7 @@ export function _getDrizzleTableFromType(type, schemaName, tableName = getDefaul
             return column;
         });
         const indexFn = (data.options?.unique == true) ? uniqueIndex : index;
-        return indexFn().using(data.options?.using ?? 'btree', ...columns);
+        return indexFn(data.name).using(data.options?.using ?? 'btree', ...columns);
     }
     const columnEntries = columnDefinitions.map((entry) => [entry.name, entry.type]);
     const drizzleSchema = dbSchema.table(tableName, fromEntries(columnEntries), (table) => [
@@ -68,7 +68,7 @@ export function _getDrizzleTableFromType(type, schemaName, tableName = getDefaul
         ...(tableReflectionData?.index?.map((data) => buildIndex(table, data)) ?? [])
     ]);
     drizzleSchema[columnDefinitionsSymbol] = columnDefinitions;
-    return drizzleSchema; // eslint-disable-line @typescript-eslint/no-unsafe-return
+    return drizzleSchema;
 }
 function getPostgresColumnEntries(type, tableName, dbSchema, path = new JsonPath({ dollar: false }), prefix = '') {
     const metadata = reflectionRegistry.getMetadata(type);

package/orm/server/repository.d.ts

@@ -1,13 +1,14 @@
-import { SQL } from 'drizzle-orm';
-import { PgTransaction as DrizzlePgTransaction, PgColumn, PgInsertValue, PgQueryResultHKT, PgUpdateSetSource } from 'drizzle-orm/pg-core';
-import { PartialDeep } from 'type-fest';
-import { Resolvable, resolveArgumentType } from '../../injector/interfaces.js';
-import type { DeepPartial, OneOrMany, Paths, Record, Type, TypedOmit, UntaggedDeep } from '../../types.js';
-import { Database } from './database.js';
-import { ColumnDefinition, type PgTableFromType } from './drizzle/schema-converter.js';
+import { type SQL } from 'drizzle-orm';
+import { PgTransaction as DrizzlePgTransaction, type PgColumn, type PgInsertValue, type PgQueryResultHKT, type PgUpdateSetSource } from 'drizzle-orm/pg-core';
+import type { PartialDeep } from 'type-fest';
+import { type Resolvable, resolveArgumentType } from '../../injector/interfaces.js';
+import type { DeepPartial, OneOrMany, Paths, Record, Type, TypedOmit } from '../../types.js';
+import type { UntaggedDeep } from '../../types/index.js';
 import type { Entity, EntityMetadata, EntityMetadataAttributes, EntityType, NewEntity } from '../entity.js';
 import type { Query } from '../query.js';
-import { Transaction, TransactionConfig } from './transaction.js';
+import { Database } from './database.js';
+import { type ColumnDefinition, type PgTableFromType } from './drizzle/schema-converter.js';
+import { type Transaction, type TransactionConfig } from './transaction.js';
 type PgTransaction = DrizzlePgTransaction<PgQueryResultHKT, Record, Record>;
 export declare const repositoryType: unique symbol;
 export type OrderOptions<T extends Entity> = {

package/orm/server/repository.js

@@ -13,6 +13,7 @@ import { PgTransaction as DrizzlePgTransaction } from 'drizzle-orm/pg-core';
 import { NotFoundError } from '../../errors/not-found.error.js';
 import { Singleton } from '../../injector/decorators.js';
 import { inject, injectArgument } from '../../injector/inject.js';
+import { resolveArgumentType } from '../../injector/interfaces.js';
 import { Schema } from '../../schema/schema.js';
 import { toArray } from '../../utils/array/array.js';
 import { fromDeepObjectEntries } from '../../utils/object/object.js';

package/orm/types.d.ts

@@ -1,31 +1,27 @@
 import type { $Type, HasDefault as DrizzleHasDefault, IsPrimaryKey as DrizzleIsPrimaryKey } from 'drizzle-orm';
 import type { boolean, date, doublePrecision, integer, jsonb, PgColumnBuilder, PgColumnBuilderBase, PgEnumColumnBuilderInitial, text, timestamp, uuid } from 'drizzle-orm/pg-core';
-import type { GetTagMetadata, Tagged, UnwrapTagged } from 'type-fest';
 import { Array, Integer } from '../schema/index.js';
 import type { AbstractConstructor, EnumerationObject, EnumerationValue, ObjectLiteral, UnionToTuple } from '../types.js';
+import type { GetTagMetadata, HasTag, Tagged, UnwrapTagged } from '../types/index.js';
 import { Column, Embedded, Index, PrimaryKey, References, Unique } from './decorators.js';
 import { Json, NumericDate, Timestamp, 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 ColumnTypeTag = 'column';
+export type EmbeddedConfigTag = 'embedded';
+export type IsPrimaryKey<T> = T extends Tagged<unknown, ColumnTypeTag, PgColumnBuilderBase> ? Tagged<UnwrapTagged<T>, ColumnTypeTag, DrizzleIsPrimaryKey<GetTagMetadata<T, ColumnTypeTag>>> : Tagged<T, ColumnTypeTag, DrizzleIsPrimaryKey<ColumnBuilder<T>>>;
+export type HasDefault<T> = T extends Tagged<unknown, ColumnTypeTag, PgColumnBuilderBase> ? Tagged<UnwrapTagged<T>, ColumnTypeTag, DrizzleHasDefault<GetTagMetadata<T, ColumnTypeTag>>> : Tagged<T, ColumnTypeTag, DrizzleHasDefault<ColumnBuilder<T>>>;
 type EnumColumn<T extends EnumerationObject, ColumnName extends string = ''> = PgEnumColumnBuilderInitial<ColumnName, UnionToTuple<`${EnumerationValue<T>}`> extends [string, ...string[]] ? UnionToTuple<`${EnumerationValue<T>}`> : ['NO_VALUES_PROVIDED']>;
-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> : T extends EnumerationObject ? string extends ColumnName ? EnumColumn<T, ColumnName> : EnumColumn<T> : T extends (infer U)[] ? string extends ColumnName ? ReturnType<ColumnBuilder<U, ColumnName>['array']> : ReturnType<ColumnBuilder<U>['array']> : 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 declare const embedded: unique symbol;
-export type Embedded<T = AbstractConstructor, P extends string = ''> = T & {
-    [embedded]: {
-        prefix: P;
-    };
-};
-export type Array<T extends Tagged<ObjectLiteral, 'column', PgColumnBuilder<any>>> = Tagged<UnwrapTagged<T>[], 'column', ReturnType<GetTagMetadata<T, 'column'>['array']>>;
-export type Json<T extends ObjectLiteral = ObjectLiteral> = Tagged<T, 'column', $Type<ReturnType<typeof jsonb>, T>>;
-export type Enum<T extends EnumerationObject> = Tagged<EnumerationValue<T>, 'column', EnumColumn<T>>;
-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 type NumericDate = Tagged<number, 'column', ReturnType<typeof date>>;
-export type Timestamp = Tagged<number, 'column', ReturnType<typeof timestamp>>;
+export type ColumnBuilder<T, ColumnName extends string = never> = HasTag<T> extends true ? T extends Tagged<T, ColumnTypeTag, any> ? GetTagMetadata<T, ColumnTypeTag> : never : 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> : T extends EnumerationObject ? string extends ColumnName ? EnumColumn<T, ColumnName> : EnumColumn<T> : T extends (infer U)[] ? string extends ColumnName ? ReturnType<ColumnBuilder<U, ColumnName>['array']> : ReturnType<ColumnBuilder<U>['array']> : never;
+export type Embedded<T = AbstractConstructor, P extends string = ''> = Tagged<T, EmbeddedConfigTag, {
+    prefix: P;
+}>;
+export type Array<T extends Tagged<ObjectLiteral, ColumnTypeTag, PgColumnBuilder<any>>> = Tagged<UnwrapTagged<T>[], ColumnTypeTag, ReturnType<GetTagMetadata<T, ColumnTypeTag>['array']>>;
+export type Json<T extends ObjectLiteral = ObjectLiteral> = Tagged<T, ColumnTypeTag, $Type<ReturnType<typeof jsonb>, T>>;
+export type Enum<T extends EnumerationObject> = Tagged<EnumerationValue<T>, ColumnTypeTag, EnumColumn<T>>;
+export type Text = Tagged<string, ColumnTypeTag, ReturnType<typeof text<string, [string, ...string[]]>>>;
+export type Uuid = Tagged<string, ColumnTypeTag, ReturnType<typeof uuid>>;
+export type Integer = Tagged<number, ColumnTypeTag, ReturnType<typeof integer>>;
+export type DoublePrecision = Tagged<number, ColumnTypeTag, ReturnType<typeof doublePrecision>>;
+export type Boolean = Tagged<number, ColumnTypeTag, ReturnType<typeof boolean>>;
+export type NumericDate = Tagged<number, ColumnTypeTag, ReturnType<typeof date>>;
+export type Timestamp = Tagged<number, ColumnTypeTag, ReturnType<typeof timestamp>>;
 export { Array, Column, Embedded, Index, Integer, Json, NumericDate, PrimaryKey, References, Timestamp, Unique, Uuid };

package/orm/types.js

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-redeclare, @typescript-eslint/naming-convention */
 import { Array, Integer } from '../schema/index.js';
 import { Column, Embedded, Index, PrimaryKey, References, Unique } from './decorators.js';
 import { Json, NumericDate, Timestamp, Uuid } from './schemas/index.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.92.43",
+  "version": "0.92.47",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -10,12 +10,12 @@
     "build": "tsc && tsc-alias",
     "build:watch": "concurrently --raw --kill-others npm:tsc:watch npm:tsc-alias:watch",
     "build:production": "rm -rf dist && npm run build && npm run build:production:copy-files",
-    "build:production:copy-files": "cp package.json .eslintrc.json tsconfig.server.json dist/ && cp tsconfig.base.json dist/tsconfig.json && npm run copy:document-management",
+    "build:production:copy-files": "cp package.json eslint.config.js tsconfig.server.json dist/ && cp tsconfig.base.json dist/tsconfig.json && npm run copy:document-management",
     "build:docs": "typedoc",
     "build:docs:watch": "typedoc --watch",
     "generate:drizzle": "drizzle-kit generate --config dist/document-management/server/drizzle.config.js",
     "copy:document-management": "rm -rf ./dist/document-management/server/drizzle && cp -r ./source/document-management/server/drizzle ./dist/document-management/server/",
-    "lint": "eslint --config .eslintrc.json --cache source/",
+    "lint": "eslint --cache source/",
     "pub": "npm run build:production && rm -vf dist/test* && rm -vrf dist/tools/ && npm publish dist/",
     "tsc:watch": "tsc --watch",
     "tsc-alias:watch": "tsc-alias --watch"
@@ -127,8 +127,7 @@
     "type-fest": "4.35"
   },
   "devDependencies": {
-    "@mxssfd/typedoc-theme": "1.1",
-    "@stylistic/eslint-plugin": "3.1",
+    "@stylistic/eslint-plugin": "4.0",
     "@types/chroma-js": "2.4",
     "@types/koa__router": "12.0",
     "@types/luxon": "3.4",
@@ -140,12 +139,9 @@
     "@typescript-eslint/eslint-plugin": "8.24",
     "concurrently": "9.1",
     "drizzle-kit": "0.30",
-    "eslint": "8.57",
-    "eslint-import-resolver-typescript": "3.8",
-    "eslint-plugin-import": "2.31",
+    "eslint": "9.20",
+    "globals": "15.15",
     "tsc-alias": "1.8",
-    "typedoc": "0.27",
-    "typedoc-plugin-missing-exports": "3.1",
     "typescript": "5.7"
   },
   "peerDependencies": {

package/pdf/pdf.service.js

@@ -71,7 +71,7 @@ import { promisify } from 'node:util';
 import { BrowserContextController } from '../browser/browser-context-controller.js';
 import { BrowserController } from '../browser/browser-controller.js';
 import { PdfRenderOptions } from '../browser/pdf-options.js';
-import { Singleton, inject, injectArgument } from '../injector/index.js';
+import { Singleton, inject, injectArgument, resolveArgumentType } from '../injector/index.js';
 import { LogLevel } from '../logger/level.js';
 import { Logger } from '../logger/logger.js';
 import { Optional } from '../schema/index.js';

package/queue/mongo/mongo-job.repository.js

@@ -12,7 +12,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { getNewId } from '../../database/index.js';
 import { Collection, MongoEntityRepository, noopTransformer } from '../../database/mongo/index.js';
-import { ForwardArg, ResolveArg, Singleton } from '../../injector/index.js';
+import { ForwardArg, ResolveArg, Singleton, resolveArgumentType } from '../../injector/index.js';
 import { Logger } from '../../logger/index.js';
 import { UniqueTagStrategy } from '../../queue/index.js';
 const indexes = [

package/queue/mongo/queue.provider.js

@@ -12,6 +12,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { ForwardArg, ResolveArg, Singleton } from '../../injector/decorators.js';
 import { Injector } from '../../injector/injector.js';
+import { resolveArgumentType } from '../../injector/interfaces.js';
 import { LockProvider } from '../../lock/index.js';
 import { MessageBusProvider } from '../../message-bus/index.js';
 import { Queue, QueueProvider } from '../../queue/index.js';

package/queue/queue.d.ts

@@ -1,6 +1,5 @@
 import type { CancellationSignal } from '../cancellation/token.js';
-import type { Resolvable } from '../injector/interfaces.js';
-import { resolveArgumentType } from '../injector/interfaces.js';
+import type { Resolvable, resolveArgumentType } from '../injector/interfaces.js';
 import { QueueEnqueueBatch } from './enqueue-batch.js';
 export type JobTag = string | number | null;
 export type Job<T> = {

package/schema/schemas/literal.d.ts

@@ -1,6 +1,6 @@
 import type { JsonPath } from '../../json-path/json-path.js';
-import { type SchemaPropertyDecorator, type SchemaDecoratorOptions } from '../decorators/index.js';
-import { Schema, SchemaOptions, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+import { type SchemaDecoratorOptions, type SchemaPropertyDecorator } from '../decorators/index.js';
+import { Schema, type SchemaOptions, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 export type LiteralSchemaOptions<T> = SchemaOptions<T>;
 export declare class LiteralSchema<const T> extends Schema<T> {
     readonly name: string;

package/search-index/elastic/config.d.ts

@@ -1,6 +1,5 @@
 import type { Entity } from '../../database/index.js';
-import { resolveArgumentType } from '../../injector/interfaces.js';
-import type { Resolvable } from '../../injector/interfaces.js';
+import type { Resolvable, resolveArgumentType } from '../../injector/interfaces.js';
 export type ElasticSearchIndexConfigArgument<T extends Entity = Entity> = string | ElasticSearchIndexConfig<T>;
 export declare abstract class ElasticSearchIndexConfig<T extends Entity = Entity> implements Resolvable<ElasticSearchIndexConfigArgument> {
     readonly indexName: string;

package/serializer/serializer.js

@@ -1,4 +1,4 @@
-/* eslint-disable @typescript-eslint/no-unsafe-return, max-lines-per-function, max-statements, complexity */
+/* eslint-disable @typescript-eslint/no-unsafe-return, @typescript-eslint/no-deprecated */
 import { CircularBuffer } from '../data-structures/circular-buffer.js';
 import { SortedArrayList } from '../data-structures/sorted-array-list.js';
 import { compareByValueSelection } from '../utils/comparison.js';
@@ -156,7 +156,7 @@ function _deserialize(serialized, context, path, depth) {
                     if (context.options.allowUnsafe !== true) {
                         throw new Error('functions are only allowed if allowUnsafe option is true');
                     }
-                    const fn = eval(nonPrimitiveData); // eslint-disable-line no-eval
+                    const fn = eval(nonPrimitiveData);
                     context.references.set(path, fn);
                     return fn;
                 }

package/signals/implementation/to-signal.d.ts

@@ -6,9 +6,9 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import type { Observable, Subscribable } from 'rxjs';
-import { SignalsInjector } from '../api.js';
+import type { SignalsInjector } from '../api.js';
 import type { Signal } from './api.js';
-import { ValueEqualityFn } from './equality.js';
+import type { ValueEqualityFn } from './equality.js';
 export interface ToSignalOptions<T> {
     /**
      * Initial value for the signal produced by `toSignal`.

package/signals/implementation/writable-signal.d.ts

@@ -1,6 +1,6 @@
-import { Signal } from './api.js';
-import { ValueEqualityFn } from './equality.js';
-import { SignalGetter } from './signal.js';
+import { type Signal } from './api.js';
+import type { ValueEqualityFn } from './equality.js';
+import { type SignalGetter } from './signal.js';
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.

package/signals/implementation/writable-signal.js

@@ -1,4 +1,3 @@
-/* eslint-disable */
 import { SIGNAL } from '../symbol.js';
 import { isSignal } from './api.js';
 import { createSignal, signalSetFn, signalUpdateFn } from './signal.js';

package/templates/providers/file.template-provider.d.ts

@@ -1,5 +1,4 @@
-import type { Resolvable } from '../../injector/interfaces.js';
-import { resolveArgumentType } from '../../injector/interfaces.js';
+import type { Resolvable, resolveArgumentType } from '../../injector/interfaces.js';
 import { Template } from '../template.model.js';
 import { TemplateProvider } from '../template.provider.js';
 export type FileTemplateProviderConfig = {

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

@@ -1,4 +1,4 @@
-import { Resolvable, resolveArgumentType } from '../../injector/interfaces.js';
+import { type 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,6 +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 { resolveArgumentType } from '../../injector/interfaces.js';
 import { StringProperty } from '../../schema/index.js';
 import { TemplateField } from '../template.model.js';
 import { TemplateResolver } from '../template.resolver.js';

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

@@ -1,6 +1,6 @@
 import type { PartialProperty, Record, TypedOmit } from '../../types.js';
 import type { ComponentClass, FunctionComponent } from 'preact';
-import { Template, TemplateField } from '../template.model.js';
+import { type 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>;

package/text/localization.service.d.ts

@@ -1,7 +1,7 @@
 import type { Observable } from 'rxjs';
 import { Logger } from '../logger/index.js';
 import type { Signal } from '../signals/api.js';
-import type { Enumeration, EnumerationValue } from '../types.js';
+import type { Enumeration, EnumerationValue, Record } from '../types.js';
 import type { PropertyName } from '../utils/object/property-name.js';
 export type Language = {
     code: string;
@@ -15,9 +15,7 @@ export type LocalizeItem<Parameters = void> = string | LocalizeFunction<Paramete
 type LocalizationTemplate = {
     [key: string]: LocalizeItem<any> | LocalizationTemplate;
 };
-export type EnumerationLocalization<T extends Enumeration = Enumeration> = {
-    [P in EnumerationValue<T>]: LocalizeItem<any>;
-};
+export type EnumerationLocalization<T extends Enumeration = Enumeration> = Record<EnumerationValue<T>, LocalizeItem<any>>;
 export type EnumerationLocalizationEntry<T extends Enumeration = Enumeration> = [enumType: T, enumName: LocalizeItem<any> | undefined, enumValues: EnumerationLocalization<T>];
 export type Localization<T extends LocalizationTemplate = LocalizationTemplate, Enums extends Enumeration[] = Enumeration[]> = {
     language: Language;

package/tsconfig.json

@@ -4,7 +4,7 @@
     "module": "nodenext",
     "moduleResolution": "nodenext",
     "lib": ["esnext", "dom"],
-    "target": "es2023",
+    "target": "es2024",
     "baseUrl": "source/",
     "rootDir": "source/",
     "outDir": "dist/",
@@ -20,27 +20,23 @@
     "experimentalDecorators": true,
 
     /* strictness */
+    "strict": true,
+    "strictPropertyInitialization": false,
     "allowUnreachableCode": false,
     "allowUnusedLabels": false,
-    "alwaysStrict": true,
     "exactOptionalPropertyTypes": false,
     "noFallthroughCasesInSwitch": true,
-    "noImplicitAny": true,
     "noImplicitOverride": true,
     "noImplicitReturns": true,
-    "noImplicitThis": true,
+    "noUncheckedSideEffectImports": true,
     "noPropertyAccessFromIndexSignature": true,
     "noUncheckedIndexedAccess": true,
     "noUnusedLocals": false,
     "noUnusedParameters": true,
-    "strict": true,
-    "strictBindCallApply": true,
-    "strictFunctionTypes": true,
-    "strictNullChecks": true,
-    "strictPropertyInitialization": false,
-    "useDefineForClassFields": true,
     "useUnknownInCatchVariables": true,
+
     "isolatedModules": true,
+    "verbatimModuleSyntax": true,
 
     /* jsx */
     "jsx": "react-jsx",

package/tsconfig.server.json

@@ -1,6 +1,6 @@
 {
   "extends": "./tsconfig.json", // in dist tsconfig.base.json is renamed to tsconfig.json
   "compilerOptions": {
-    "target": "es2023"
+    "target": "es2024"
   }
 }

package/types/index.d.ts

@@ -0,0 +1,2 @@
+export type * from './geo-json.js';
+export type * from './tagged.js';

package/types/index.js

@@ -0,0 +1 @@
+export {};

package/types/tagged.d.ts

@@ -0,0 +1,16 @@
+import type { Record } from '../types.js';
+export declare const tag: unique symbol;
+export declare const type: unique symbol;
+export type TagContainer<Type, Token> = {
+    readonly [tag]?: Token;
+    readonly [type]?: Type;
+};
+export type Tag<Type, Token extends PropertyKey, TagMetadata> = TagContainer<Type, Record<Token, TagMetadata>>;
+export type HasTag<T, Token = unknown> = T extends TagContainer<unknown, Token> ? true : false;
+export type Tagged<Type = unknown, TagName extends PropertyKey = PropertyKey, TagMetadata = unknown> = Type & Tag<Type, TagName, TagMetadata>;
+export type GetTagMetadata<Type extends Tag<unknown, TagName, unknown>, TagName extends PropertyKey> = NonNullable<Type[typeof tag]>[TagName];
+export type UnwrapTagged<TaggedType extends Tag<unknown, PropertyKey, any>> = TaggedType extends Tagged<infer Type, PropertyKey, any> ? Type : never;
+export type Untagged<T> = T extends Tagged ? UnwrapTagged<T> : T;
+export type UntaggedDeep<T> = T extends Tagged ? UnwrapTagged<T> : T extends readonly (infer U)[] ? UntaggedDeep<U>[] : T extends Record ? {
+    [P in keyof T]: UntaggedDeep<T[P]>;
+} : Untagged<T>;

package/types/tagged.js

@@ -0,0 +1 @@
+export {};

package/types.d.ts

@@ -1,5 +1,5 @@
 import type { Observable } from 'rxjs';
-import type { CamelCase, Except, IsEqual, LiteralUnion, Tagged, UnwrapTagged } from 'type-fest';
+import type { CamelCase, Except, IsEqual, LiteralUnion } from 'type-fest';
 import type { Signal } from './signals/api.js';
 export type ObjectLiteral = {};
 export type Function<P extends any[] = any[], R = any> = (...params: P) => R;
@@ -94,10 +94,10 @@ export type DeepWritable<T> = T extends readonly (infer U)[] ? DeepWritable<U>[]
     -readonly [P in keyof T]: DeepWritable<T[P]>;
 };
 export type RequiredKeys<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? never : K;
+    [K in keyof T]-?: ObjectLiteral extends Pick<T, K> ? never : K;
 }[keyof T];
 export type OptionalKeys<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? K : never;
+    [K in keyof T]-?: ObjectLiteral extends Pick<T, K> ? K : never;
 }[keyof T];
 export type TypedOmit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
 export type TypedExtract<T, U extends T> = T extends U ? T : never;
@@ -105,7 +105,7 @@ export type ReplaceIfUnknown<T, U> = IfUnknown<T, U, T>;
 export type OmitNever<T extends Record> = {
     [K in keyof T as T[K] extends never ? never : K]: T[K];
 };
-export type BaseType<T extends Exclude<Primitive, null | undefined>> = T extends string ? string : never | T extends number ? number : never | T extends boolean ? boolean : never | T extends bigint ? bigint : never | T extends symbol ? symbol : never;
+export type BaseType<T extends Exclude<Primitive, null | undefined>> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T extends bigint ? bigint : T extends symbol ? symbol : T extends null ? null : T extends undefined ? undefined : never;
 export type SharedProperties<A, B, C = unknown, D = unknown, E = unknown, F = unknown, G = unknown, H = unknown, I = unknown, J = unknown> = OmitNever<Pick<A & B & C & D & E & F & G & H & I & J, keyof A & keyof B & keyof ReplaceIfUnknown<C, never> & keyof ReplaceIfUnknown<D, never> & keyof ReplaceIfUnknown<E, never> & keyof ReplaceIfUnknown<F, never> & keyof ReplaceIfUnknown<G, never> & keyof ReplaceIfUnknown<H, never> & keyof ReplaceIfUnknown<I, never> & keyof ReplaceIfUnknown<J, never>>>;
 /**
  * Omit properties from a type that extend from a specific type.
@@ -158,7 +158,7 @@ export type IfAny<T, Then, Else = never> = true extends (false & T) ? Then : Els
 export type IfUnknown<T, Then, Else = never> = unknown extends T ? Then : Else;
 export type IsAny<T> = IfAny<T, true, false>;
 export type IsUnknown<T> = IfUnknown<T, true, false>;
-export type If<B extends Boolean, Then, Else> = B extends true ? Then : Else;
+export type If<B extends boolean, Then, Else> = B extends true ? Then : Else;
 export type Not<T extends boolean> = T extends true ? false : true;
 export type Fallback<T, F> = [T] extends [never] ? F : T;
 export type PartialProperty<T, P extends keyof T> = Omit<T, P> & Partial<Pick<T, P>>;
@@ -195,7 +195,7 @@ export type Paths<T extends Record> = T extends object ? {
 export type TypeFromPath<T extends Record, Path extends Paths<T> | string> = {
     [K in Path]: K extends keyof T ? T[K] : K extends `${infer P}.${infer S}` ? T[P] extends Record ? TypeFromPath<T[P], S> : never : never;
 }[Path];
-export type ConstructorParameterDecorator = (target: Object, propertyKey: undefined, parameterIndex: number) => void;
+export type ConstructorParameterDecorator = (target: object, propertyKey: undefined, parameterIndex: number) => void;
 export type ReactiveValue<T> = T | Signal<T> | Observable<T>;
 export type PascalCase<Value> = CamelCase<Value> extends string ? Capitalize<CamelCase<Value>> : CamelCase<Value>;
 type PickOmitDeepSelection<T> = T extends (infer U)[] ? (boolean | PickOmitDeepSelection<U>) : T extends Record<any> ? (boolean | {
@@ -211,8 +211,4 @@ export type OmitDeep<T, S extends OmitDeepSelection<T>> = T extends Record<any>
         S[Extract<P, keyof S>]
     ] extends ([false] | [never]) ? T[P] : S[Extract<P, keyof S>] extends Record<any> ? T[P] extends (infer U)[] ? S[Extract<P, keyof S>] extends OmitDeepSelection<U> ? OmitDeep<U, S[Extract<P, keyof S>]>[] : never : S[Extract<P, keyof S>] extends OmitDeepSelection<T[P]> ? OmitDeep<T[P], S[Extract<P, keyof S>]> : never : never;
 }> : T;
-export type Untagged<T> = T extends Tagged<unknown, any, any> ? UnwrapTagged<T> : T;
-export type UntaggedDeep<T> = T extends Tagged<unknown, any, any> ? UnwrapTagged<T> : T extends readonly (infer U)[] ? UntaggedDeep<U>[] : T extends Record ? {
-    [P in keyof T]: UntaggedDeep<T[P]>;
-} : Untagged<T>;
 export {};

package/utils/async-iterable-helpers/multiplex.js

@@ -5,8 +5,7 @@ export function multiplexAsync(iterable, count, bufferSize) {
         throw new Error('bufferSize must be greater than 0');
     }
     const feedableIterables = createArray(count, () => new FeedableAsyncIterable());
-    // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    multiplexTo(iterable, feedableIterables, bufferSize);
+    void multiplexTo(iterable, feedableIterables, bufferSize);
     return feedableIterables;
 }
 async function multiplexTo(input, outputs, bufferSize) {

package/utils/benchmark.js

@@ -26,7 +26,7 @@ export function measureBenchmarkOverhead(duration = 250) {
     do {
         warmupFunction();
         operations++;
-    } while (timer.milliseconds < testDuration || warmupPhase);
+    } while (timer.milliseconds < testDuration || warmupPhase); // eslint-disable-line @typescript-eslint/no-unnecessary-condition
     timer.stop();
     microsecondsPerTimerRead = timer.microseconds / operations;
 }

package/utils/comparison.js

@@ -46,7 +46,6 @@ export const orderRest = Symbol('Order rest');
 export function compareByValueSelectionToOrder(order, selector) {
     const indexMapEntries = order.map((orderItem, index) => [orderItem, index]);
     const indexMap = new Map(indexMapEntries);
-    // eslint-disable-next-line @typescript-eslint/no-shadow
     return function compareByValueSelectionToOrder(a, b) {
         const selectedA = selector(a);
         const selectedB = selector(b);

package/utils/cryptography.d.ts

@@ -27,10 +27,8 @@ export interface CryptionResult {
 export interface DecryptionResult extends CryptionResult {
     toUtf8(): Promise<string>;
 }
-export interface DigestResult extends CryptionResult {
-}
-export interface SignResult extends CryptionResult {
-}
+export type DigestResult = CryptionResult;
+export type SignResult = CryptionResult;
 /**
  * Encrypt data
  * @param algorithm algorithm as supported by Web Crypto API

package/utils/event-loop.js

@@ -17,6 +17,5 @@ export function runEventLoopWatcher(logger, cancellationSignal) {
         .watch(0, 100, AggregationMode.ThirdQuartile)
         .subscribe((delay) => logger.debug(`eventloop: ${formatDuration(delay, 2)}`));
     sampler.start();
-    // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    cancellationSignal.then(async () => sampler.stop());
+    void cancellationSignal.then(async () => sampler.stop());
 }

package/utils/iterable-helpers/first-or-default.js

@@ -1,7 +1,6 @@
 import { filter } from './filter.js';
 export function firstOrDefault(iterable, defaultValue, predicate) {
     const source = (predicate == undefined) ? iterable : filter(iterable, predicate);
-    // eslint-disable-next-line no-unreachable-loop
     for (const item of source) {
         return item;
     }

package/utils/iterable-helpers/first.js

@@ -1,7 +1,6 @@
 import { filter } from './filter.js';
 export function first(iterable, predicate) {
     const source = (predicate == undefined) ? iterable : filter(iterable, predicate);
-    // eslint-disable-next-line no-unreachable-loop
     for (const item of source) {
         return item;
     }

package/utils/iterable-helpers/group-to-map.js

@@ -15,7 +15,7 @@ export function groupToMap(iterable, ...selectors) {
     }
     const map = new MultiKeyMap();
     for (const item of iterable) {
-        const groupKeys = selectors.map((selector) => selector(item, index)); // eslint-disable-line @typescript-eslint/no-loop-func
+        const groupKeys = selectors.map((selector) => selector(item, index));
         index++;
         if (!map.has(groupKeys)) {
             map.set(groupKeys, []);

package/utils/iterable-helpers/last-or-default.js

@@ -8,7 +8,7 @@ export function lastOrDefault(iterable, defaultValue, predicate) {
         lastItem = item;
     }
     if (hasLastItem) {
-        return lastItem; // eslint-disable-line @typescript-eslint/no-non-null-assertion
+        return lastItem;
     }
     return defaultValue;
 }