@tstdl/base 0.93.69 → 0.93.71

package/audit/module.js

@@ -28,6 +28,6 @@ export async function migrateAuditSchema() {
     await migrate(database, {
         migrationsSchema: 'audit',
         migrationsTable: '_migrations',
-        migrationsFolder: import.meta.resolve('./drizzle').replace('file://', ''),
+        migrationsFolder: import.meta.resolve('./drizzle'),
     });
 }

package/authentication/server/module.js

@@ -50,6 +50,6 @@ export async function migrateAuthenticationSchema() {
     await migrate(database, {
         migrationsSchema: 'authentication',
         migrationsTable: '_migrations',
-        migrationsFolder: import.meta.resolve('./drizzle').replace('file://', ''),
+        migrationsFolder: import.meta.resolve('./drizzle'),
     });
 }

package/document-management/server/module.js

@@ -17,6 +17,6 @@ export async function migrateDocumentManagementSchema() {
     await migrate(database, {
         migrationsSchema: 'document_management',
         migrationsTable: '_migrations',
-        migrationsFolder: import.meta.resolve('./drizzle').replace('file://', ''),
+        migrationsFolder: import.meta.resolve('./drizzle'),
     });
 }

package/formats/formats.d.ts

@@ -1,11 +1,20 @@
-export declare let locale: string;
-export declare function configureFormats(options: {
+import { DateTime } from 'luxon';
+import type { ValueOrProvider } from '../utils/value-or-provider.js';
+type LocaleOption = {
     locale?: string;
-}): void;
+};
+export type ConfigureLocaleOptions = {
+    locale?: ValueOrProvider<string>;
+};
+export type FormatNumberOptions = Intl.NumberFormatOptions & LocaleOption;
+export type FormatDateTimeOptions = Intl.DateTimeFormatOptions & LocaleOption;
+export type FormatNumberValue = number | bigint | Intl.StringNumericLiteral;
+export type FormatDateTimeValue = number | Date | DateTime;
+export declare let getLocale: () => string;
+export declare function configureFormats({ locale }: ConfigureLocaleOptions): void;
 export declare const integerFormat: Intl.NumberFormatOptions;
 export declare const decimalFormat: Intl.NumberFormatOptions;
 export declare const decimal1Format: Intl.NumberFormatOptions;
-export declare const yearFormat: Intl.NumberFormatOptions;
 export declare const dateTimeNumeric: Intl.DateTimeFormatOptions;
 export declare const dateTimeShort: Intl.DateTimeFormatOptions;
 export declare const dateTimeLong: Intl.DateTimeFormatOptions;
@@ -16,19 +25,21 @@ export declare const timeShort: Intl.DateTimeFormatOptions;
 export declare const currencyFormat: Intl.NumberFormatOptions;
 export declare const currencyFormatWithoutCents: Intl.NumberFormatOptions;
 export declare const percentFormat: Intl.NumberFormatOptions;
-export declare function formatNumber(value: number, format?: Intl.NumberFormatOptions): string;
-export declare function formatInteger(value: number): string;
-export declare function formatDecimal(value: number, minimumFractionDigits?: number, maximumFractionDigits?: number): string;
-export declare function formatYear(value: number): string;
-export declare function formatTimeShort(value: number): string;
-export declare function formatDateShort(value: Date | number): string;
-export declare function formatDate(dateOrTimestamp: number | Date): string;
-export declare function formatNumericDate(numericDate: number): string;
-export declare function formatCurrency(value: number, currency: string): string;
-export declare function formatCurrencyWithoutCents(value: number, currency: string): string;
-export declare function formatEuro(value: number): string;
-export declare function formatEuroWithoutCents(value: number): string;
-export declare function formatPercent(value: number): string;
+export declare function formatNumber(value: FormatNumberValue, format?: FormatNumberOptions): string;
+export declare function formatDateTime(value: number | Date | DateTime, format?: FormatDateTimeOptions): string;
+export declare function formatInteger(value: FormatNumberValue, format?: FormatNumberOptions): string;
+export declare function formatDecimal(value: FormatNumberValue, format?: FormatNumberOptions): string;
+export declare function formatCurrency(value: FormatNumberValue, currency: string, format?: FormatNumberOptions): string;
+export declare function formatCurrencyWithoutCents(value: FormatNumberValue, currency: string, format?: FormatNumberOptions): string;
+export declare function formatEuro(value: FormatNumberValue, format?: FormatNumberOptions): string;
+export declare function formatEuroWithoutCents(value: FormatNumberValue, format?: FormatNumberOptions): string;
+export declare function formatPercent(value: FormatNumberValue, format?: FormatNumberOptions): string;
+export declare function formatTimeShort(value: FormatDateTimeValue, format?: FormatDateTimeOptions): string;
+export declare function formatDateShort(value: FormatDateTimeValue, format?: FormatDateTimeOptions): string;
+export declare function formatDate(dateOrTimestamp: FormatDateTimeValue, format?: FormatDateTimeOptions): string;
+export declare function formatNumericDate(numericDate: number, options?: FormatDateTimeOptions): string;
+export declare function formatNumericDateShort(numericDate: number, options?: FormatDateTimeOptions): string;
+export declare function formatNumericDateLong(numericDate: number, options?: FormatDateTimeOptions): string;
 export type FormatPersonNameOptions<F = unknown> = {
     lastNameFirst?: boolean;
     fallback?: F;
@@ -45,7 +56,4 @@ export declare function formatPersonName(person: {
 } | null | undefined, options?: FormatPersonNameOptions & {
     fallback?: undefined;
 }): string;
-/**
- * @deprecated use {@link formatPersonName} instead
- */
-export declare const formatUserName: typeof formatPersonName;
+export {};

package/formats/formats.js

@@ -1,9 +1,13 @@
-import { numericDateToTimestamp } from '../utils/date-time.js';
-import { memoize, memoizeSingle } from '../utils/function/memoize.js';
-import { isNullOrUndefined, isUndefined } from '../utils/type-guards.js';
-export let locale = 'de-DE';
-export function configureFormats(options) {
-    locale = options.locale ?? locale;
+import { DateTime } from 'luxon';
+import { numericDateToDate } from '../utils/date-time.js';
+import { isDefined, isNullOrUndefined, isString } from '../utils/type-guards.js';
+const numberFormatterMap = new Map();
+const dateTimeFormatterMap = new Map();
+export let getLocale = () => 'de-DE';
+export function configureFormats({ locale }) {
+    getLocale = (isString(locale)
+        ? () => locale
+        : locale) ?? getLocale;
 }
 export const integerFormat = {
     useGrouping: true,
@@ -19,10 +23,6 @@ export const decimal1Format = {
     minimumFractionDigits: 0,
     maximumFractionDigits: 1,
 };
-export const yearFormat = {
-    useGrouping: false,
-    maximumFractionDigits: 0,
-};
 export const dateTimeNumeric = {
     year: 'numeric',
     month: '2-digit',
@@ -77,57 +77,54 @@ export const percentFormat = {
     minimumFractionDigits: 2,
     maximumFractionDigits: 2,
 };
-const getDecimalFormatter = memoize(_getDecimalFormatter);
-const integerFormatter = memoizeSingle((loc) => Intl.NumberFormat(loc, integerFormat));
-const decimalFormatter = memoizeSingle((loc) => Intl.NumberFormat(loc, decimalFormat));
-const yearFormatter = memoizeSingle((loc) => Intl.NumberFormat(loc, yearFormat));
-const percentFormatter = memoizeSingle((loc) => Intl.NumberFormat(loc, percentFormat));
-const dateFormatter = memoizeSingle((loc) => Intl.DateTimeFormat(loc, dateShort));
-const currencyFormatter = memoize((currency, loc) => Intl.NumberFormat(loc, { ...currencyFormat, currency }));
-const currencyFormatterWithoutCents = memoize((currency, loc) => Intl.NumberFormat(loc, { ...currencyFormatWithoutCents, currency }));
-const timeShortFormatter = memoizeSingle((loc) => Intl.DateTimeFormat(loc, timeShort));
-const dateShortFormatter = memoizeSingle((loc) => Intl.DateTimeFormat(loc, dateShort));
 export function formatNumber(value, format) {
-    return Intl.NumberFormat(locale, format).format(value);
+    const locale = format?.locale ?? getLocale();
+    return getNumberFormatter(locale, format).format(value);
 }
-export function formatInteger(value) {
-    return integerFormatter(locale).format(value);
+export function formatDateTime(value, format) {
+    const date = DateTime.isDateTime(value) ? value.toJSDate() : value;
+    const locale = format?.locale ?? getLocale();
+    return getDateTimeFormatter(locale, format).format(date);
 }
-export function formatDecimal(value, minimumFractionDigits, maximumFractionDigits) {
-    if (isUndefined(minimumFractionDigits) && isUndefined(maximumFractionDigits)) {
-        return decimalFormatter(locale).format(value);
-    }
-    return getDecimalFormatter(locale, minimumFractionDigits ?? 2, maximumFractionDigits ?? 2).format(value);
+export function formatInteger(value, format) {
+    return formatNumber(value, { ...integerFormat, ...format });
+}
+export function formatDecimal(value, format) {
+    return formatNumber(value, { ...decimalFormat, ...format });
 }
-export function formatYear(value) {
-    return yearFormatter(locale).format(value);
+export function formatCurrency(value, currency, format) {
+    return formatNumber(value, { ...currencyFormat, currency, ...format });
 }
-export function formatTimeShort(value) {
-    return timeShortFormatter(locale).format(new Date(1970, 1, 1, 0, 0, 0, value));
+export function formatCurrencyWithoutCents(value, currency, format) {
+    return formatNumber(value, { ...currencyFormatWithoutCents, currency, ...format });
 }
-export function formatDateShort(value) {
-    return dateShortFormatter(locale).format(value);
+export function formatEuro(value, format) {
+    return formatCurrency(value, 'EUR', format);
 }
-export function formatDate(dateOrTimestamp) {
-    return dateFormatter(locale).format(dateOrTimestamp);
+export function formatEuroWithoutCents(value, format) {
+    return formatCurrencyWithoutCents(value, 'EUR', format);
 }
-export function formatNumericDate(numericDate) {
-    return formatDate(numericDateToTimestamp(numericDate));
+export function formatPercent(value, format) {
+    return formatNumber(value, { ...percentFormat, ...format });
 }
-export function formatCurrency(value, currency) {
-    return currencyFormatter(currency, locale).format(value);
+export function formatTimeShort(value, format) {
+    return formatDateTime(value, { ...timeShort, ...format });
 }
-export function formatCurrencyWithoutCents(value, currency) {
-    return currencyFormatterWithoutCents(currency, locale).format(value);
+export function formatDateShort(value, format) {
+    return formatDateTime(value, { ...dateShort, ...format });
 }
-export function formatEuro(value) {
-    return currencyFormatter('EUR', locale).format(value);
+export function formatDate(dateOrTimestamp, format) {
+    return formatDateTime(dateOrTimestamp, { ...dateShort, ...format });
 }
-export function formatEuroWithoutCents(value) {
-    return currencyFormatterWithoutCents('EUR', locale).format(value);
+export function formatNumericDate(numericDate, options) {
+    const timestamp = numericDateToDate(numericDate);
+    return formatDateTime(timestamp, { ...dateShort, ...options });
 }
-export function formatPercent(value) {
-    return percentFormatter(locale).format(value);
+export function formatNumericDateShort(numericDate, options) {
+    return formatNumericDate(numericDate, { ...dateShort, ...options });
+}
+export function formatNumericDateLong(numericDate, options) {
+    return formatNumericDate(numericDate, { ...dateLong, ...options });
 }
 export function formatPersonName(person, { lastNameFirst = false, fallback } = {}) {
     if (isNullOrUndefined(person?.firstName) || isNullOrUndefined(person.lastName)) {
@@ -138,14 +135,23 @@ export function formatPersonName(person, { lastNameFirst = false, fallback } = {
     }
     return `${person.firstName} ${person.lastName}`;
 }
-/**
- * @deprecated use {@link formatPersonName} instead
- */
-export const formatUserName = formatPersonName;
-function _getDecimalFormatter(locale, minimumFractionDigits = 2, maximumFractionDigits = 2) {
-    return Intl.NumberFormat(locale, {
-        useGrouping: true,
-        minimumFractionDigits,
-        maximumFractionDigits,
-    });
+function getNumberFormatter(locale, options) {
+    const key = JSON.stringify({ locale, options });
+    const existing = numberFormatterMap.get(key);
+    if (isDefined(existing)) {
+        return existing;
+    }
+    const formatter = new Intl.NumberFormat(locale, options);
+    numberFormatterMap.set(key, formatter);
+    return formatter;
+}
+function getDateTimeFormatter(locale, options) {
+    const key = JSON.stringify({ locale, options });
+    const existing = dateTimeFormatterMap.get(key);
+    if (isDefined(existing)) {
+        return existing;
+    }
+    const formatter = new Intl.DateTimeFormat(locale, options);
+    dateTimeFormatterMap.set(key, formatter);
+    return formatter;
 }

package/key-value-store/postgres/module.js

@@ -18,6 +18,6 @@ export async function migratePostgresKeyValueStoreSchema() {
     await migrate(database, {
         migrationsSchema: 'key_value_store',
         migrationsTable: '_migrations',
-        migrationsFolder: import.meta.resolve('./drizzle').replace('file://', ''),
+        migrationsFolder: import.meta.resolve('./drizzle'),
     });
 }

package/lock/postgres/module.js

@@ -21,6 +21,6 @@ export async function migratePostgresLockSchema() {
     await migrate(database, {
         migrationsSchema: 'lock',
         migrationsTable: '_migrations',
-        migrationsFolder: import.meta.resolve('./drizzle').replace('file://', ''),
+        migrationsFolder: import.meta.resolve('./drizzle'),
     });
 }

package/mail/module.js

@@ -31,6 +31,6 @@ export async function migrateMailSchema() {
     await migrate(database, {
         migrationsSchema: 'mail',
         migrationsTable: '_migrations',
-        migrationsFolder: import.meta.resolve('./drizzle').replace('file://', ''),
+        migrationsFolder: import.meta.resolve('./drizzle'),
     });
 }

package/orm/server/database.d.ts

@@ -4,7 +4,7 @@
  * It sets up the dependency injection for the database instance.
  */
 import { NodePgDatabase } from 'drizzle-orm/node-postgres';
-import { migrate } from 'drizzle-orm/node-postgres/migrator';
+import { migrate as drizzleMigrate } from 'drizzle-orm/node-postgres/migrator';
 import { type PoolConfig } from 'pg';
 import type { Resolvable, resolveArgumentType } from '../../injector/interfaces.js';
 /**
@@ -20,4 +20,6 @@ export type DatabaseArgument = PoolConfig;
 export declare class Database extends NodePgDatabase<any> implements Resolvable<DatabaseArgument> {
     readonly [resolveArgumentType]?: DatabaseArgument;
 }
-export { migrate };
+type MigrateParameters = Parameters<typeof drizzleMigrate>;
+export declare function migrate(db: MigrateParameters[0], config: MigrateParameters[1]): Promise<void>;
+export {};

package/orm/server/database.js

@@ -10,7 +10,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
  * It sets up the dependency injection for the database instance.
  */
 import { drizzle, NodePgDatabase } from 'drizzle-orm/node-postgres';
-import { migrate } from 'drizzle-orm/node-postgres/migrator';
+import { migrate as drizzleMigrate } from 'drizzle-orm/node-postgres/migrator';
 import { Pool } from 'pg';
 import { inject, Injector, ReplaceClass } from '../../injector/index.js';
 import { isUndefined } from '../../utils/type-guards.js';
@@ -41,4 +41,9 @@ Injector.registerSingleton(Database, {
         return drizzle(pool);
     },
 });
-export { migrate };
+export async function migrate(db, config) {
+    const migrationsFolder = config.migrationsFolder
+        .replace('file://', '') // drizzle doesn't like it
+        .replace(/index.jsx$/, ''); // workaround for weird import.meta.resolve behavior with tsx
+    await drizzleMigrate(db, { ...config, migrationsFolder });
+}

package/orm/server/transactional.d.ts

@@ -22,7 +22,7 @@ declare const getCurrentTransactionalContext: {
 export { getCurrentTransactionalContext, isInTransactionalContext, runInTransactionalContext };
 export declare abstract class Transactional<ContextData = unknown> {
     #private;
-    readonly session: Database | PgTransaction;
+    readonly session: PgTransaction | Database;
     readonly isInTransaction: boolean;
     constructor();
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.69",
+  "version": "0.93.71",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -140,9 +140,9 @@
     "type-fest": "^5.3"
   },
   "peerDependencies": {
-    "@genkit-ai/google-genai": "^1.25",
+    "@genkit-ai/google-genai": "^1.26",
     "@google-cloud/storage": "^7.18",
-    "@google/genai": "^1.32",
+    "@google/genai": "^1.34",
     "@toon-format/toon": "^2.1.0",
     "@tstdl/angular": "^0.93",
     "@zxcvbn-ts/core": "^3.0",
@@ -151,7 +151,7 @@
     "@zxcvbn-ts/language-en": "^3.0",
     "drizzle-orm": "^0.45",
     "file-type": "^21.1",
-    "genkit": "^1.25",
+    "genkit": "^1.26",
     "handlebars": "^4.7",
     "minio": "^8.0",
     "mjml": "^4.18",
@@ -175,9 +175,9 @@
     "@types/koa__router": "12.0",
     "@types/luxon": "3.7",
     "@types/mjml": "4.7",
-    "@types/node": "24",
+    "@types/node": "25",
     "@types/nodemailer": "7.0",
-    "@types/pg": "8.15",
+    "@types/pg": "8.16",
     "concurrently": "9.2",
     "drizzle-kit": "0.31",
     "eslint": "9.39",

package/queue/postgres/module.js

@@ -24,6 +24,6 @@ export async function migratePostgresQueueSchema() {
     await migrate(database, {
         migrationsSchema: 'queue',
         migrationsTable: '_migrations',
-        migrationsFolder: import.meta.resolve('./drizzle').replace('file://', ''),
+        migrationsFolder: import.meta.resolve('./drizzle'),
     });
 }

package/rpc/endpoints/message-port.rpc-endpoint.d.ts

@@ -20,7 +20,6 @@ type MessagePortDataMessage<T> = MessagePortMessageBase<'data'> & {
 type MessagePortMessage<T> = MessagePortOpenChannelMessage | MessagePortCloseChannelMessage | MessagePortDataMessage<T>;
 export declare class MessagePortRpcChannel<Data = any, Req = any, Res = any> extends RpcChannel<Data, Req, Res> {
     #private;
-    private readonly _postMessage;
     private transport;
     readonly messagePortMessage$: Observable<MessagePortMessage<RpcChannelMessage<Data, Req, Res>>>;
     channelMessages$: Observable<RpcChannelMessage<Data, Req, Res>>;
@@ -30,9 +29,9 @@ export declare class MessagePortRpcChannel<Data = any, Req = any, Res = any> ext
     lastSequence: number;
     constructor(id: string, transport: MessagePortRpcTransport | undefined, endpoint: MessagePortRpcEndpoint);
     setTransport(transport: MessagePortRpcTransport): void;
-    postPortMessage(message: MessagePortMessage<RpcChannelMessage<Data, Req, Res>>, transfer?: any[]): void;
+    postPortMessage(message: MessagePortMessage<RpcChannelMessage<Data, Req, Res>>, transferOrOptions?: Transferable[] | NodeWorkerThreads.Transferable[] | NodeWorkerThreads.StructuredSerializeOptions | StructuredSerializeOptions): void;
     close(): void;
-    postMessage(message: RpcChannelMessage<Data, Req, Res>, transfer?: any[] | undefined): void | Promise<void>;
+    postMessage(message: RpcChannelMessage<Data, Req, Res>, transfer?: Transferable[] | StructuredSerializeOptions): void | Promise<void>;
 }
 export declare class MessagePortRpcEndpoint extends RpcEndpoint {
     #private;

package/rpc/endpoints/message-port.rpc-endpoint.js

@@ -6,7 +6,6 @@ import { RpcChannel, RpcEndpoint } from '../rpc.endpoint.js';
 export class MessagePortRpcChannel extends RpcChannel {
     #transportSubject = new ReplaySubject(1);
     #closeSubject = new Subject();
-    _postMessage;
     transport = { postMessage: deferThrow(() => new Error('Rpc transport not yet initialized.')) };
     messagePortMessage$;
     channelMessages$;
@@ -22,9 +21,6 @@ export class MessagePortRpcChannel extends RpcChannel {
         }
         this.messagePortMessage$ = this.#transportSubject.pipe(startWith(transport), filter(isDefined), switchMap((newTransport) => fromEvent(newTransport, 'message')), takeUntil(this.#closeSubject), map((message) => ((message instanceof MessageEvent) ? message.data : message)), shareReplay({ bufferSize: 0, refCount: true }));
         this.channelMessages$ = this.messagePortMessage$.pipe(filter((message) => message.type == 'data'), map((message) => message.data));
-        this._postMessage = isBrowser
-            ? (data, transfer) => this.transport.postMessage(data, { transfer })
-            : (data, transfer) => this.transport.postMessage(data, transfer);
         if (transport instanceof MessagePort) {
             transport.start();
         }
@@ -39,8 +35,8 @@ export class MessagePortRpcChannel extends RpcChannel {
         this.#transportSubject.next(transport);
         this.#transportSubject.complete();
     }
-    postPortMessage(message, transfer) {
-        this._postMessage(message, transfer);
+    postPortMessage(message, transferOrOptions) {
+        this.transport.postMessage(message, transferOrOptions);
     }
     close() {
         this.postPortMessage({ seq: this.sequence++, type: 'close-channel' });

package/test/module.js

@@ -12,6 +12,6 @@ export async function migrateTestSchema() {
     await migrate(database, {
         migrationsSchema: 'test',
         migrationsTable: '_migrations',
-        migrationsFolder: import.meta.resolve('./drizzle').replace('file://', ''),
+        migrationsFolder: import.meta.resolve('./drizzle'),
     });
 }

package/test-schema.d.ts

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

package/test-schema.js

@@ -0,0 +1,124 @@
+import z from 'zod';
+import { Application } from './application/application.js';
+import { provideModule, provideSignalHandler } from './application/providers.js';
+import { PrettyPrintLogFormatter, provideConsoleLogTransport } from './logger/index.js';
+import { array, boolean, literal, number, object, optional, string, union } from './schema/index.js';
+import { benchmark } from './utils/benchmark.js';
+function logResult(name, tstdl, zod) {
+    const faster = tstdl.millisecondsPerOperation < zod.millisecondsPerOperation ? 'TSTDL' : 'Zod';
+    const factor = tstdl.millisecondsPerOperation < zod.millisecondsPerOperation ? zod.millisecondsPerOperation / tstdl.millisecondsPerOperation : tstdl.millisecondsPerOperation / zod.millisecondsPerOperation;
+    console.log(`\n--- ${name} ---`);
+    console.log(`TSTDL: ${tstdl.operationsPerMillisecond.toFixed(2)} ops/ms`);
+    console.log(`Zod:   ${zod.operationsPerMillisecond.toFixed(2)} ops/ms`);
+    console.log(`Result: ${faster} is ${factor.toFixed(2)}x faster`);
+}
+// --- SETUP SCHEMAS ---
+// 1. Primitive Schema
+const tstdlString = string();
+const zodString = z.string();
+// 2. Simple Object
+const tstdlUser = object({
+    name: string(),
+    age: number(),
+    isActive: boolean(),
+});
+const zodUser = z.object({
+    name: z.string(),
+    age: z.number(),
+    isActive: z.boolean(),
+});
+// 3. Complex Nested Schema
+const tstdlComplex = object({
+    id: number(),
+    tags: array(string()),
+    metadata: optional(object({
+        createdAt: number(),
+        source: union(literal('web'), literal('mobile')),
+    })),
+});
+const zodComplex = z.object({
+    id: z.number(),
+    tags: z.array(z.string()),
+    metadata: z.object({
+        createdAt: z.number(),
+        source: z.union([z.literal('web'), z.literal('mobile')]),
+    }).optional(),
+});
+// 4. Large Array
+const tstdlArray = array(number());
+const zodArray = z.array(z.number());
+// --- DATA ---
+const validString = 'Hello World';
+const validUser = {
+    name: 'Alice',
+    age: 30,
+    isActive: true,
+};
+const validComplex = {
+    id: 101,
+    tags: ['admin', 'staff', 'verified'],
+    metadata: {
+        createdAt: 1678900000,
+        source: 'web',
+    },
+};
+const largeArrayData = Array.from({ length: 1000 }, (_, i) => i);
+const invalidUser = {
+    name: 'Bob',
+    age: '30', // Invalid: string instead of number
+    isActive: true,
+};
+// --- RUN BENCHMARKS ---
+console.log('Starting Benchmarks...');
+// 1. Primitive Parsing
+const ITERATIONS_PRIMITIVE = 1_000_000;
+const zodPrim = benchmark(ITERATIONS_PRIMITIVE, () => zodString.parse(validString));
+const tstdlPrim = benchmark(ITERATIONS_PRIMITIVE, () => tstdlString.parse(validString));
+logResult(`Primitive String Parse (${ITERATIONS_PRIMITIVE} ops)`, tstdlPrim, zodPrim);
+// 2. Simple Object Parsing
+const ITERATIONS_OBJ = 500_000;
+const zodObj = benchmark(ITERATIONS_OBJ, () => zodUser.parse(validUser));
+const tstdlObj = benchmark(ITERATIONS_OBJ, () => tstdlUser.parse(validUser));
+logResult(`Simple Object Parse (${ITERATIONS_OBJ} ops)`, tstdlObj, zodObj);
+// 3. Complex Nested Object Parsing
+const ITERATIONS_COMPLEX = 200_000;
+const zodCmplx = benchmark(ITERATIONS_COMPLEX, () => zodComplex.parse(validComplex));
+const tstdlCmplx = benchmark(ITERATIONS_COMPLEX, () => tstdlComplex.parse(validComplex));
+logResult(`Complex Object Parse (${ITERATIONS_COMPLEX} ops)`, tstdlCmplx, zodCmplx);
+// 4. Large Array Parsing
+const ITERATIONS_ARRAY = 5_000;
+const zodArr = benchmark(ITERATIONS_ARRAY, () => zodArray.parse(largeArrayData));
+const tstdlArr = benchmark(ITERATIONS_ARRAY, () => tstdlArray.parse(largeArrayData));
+logResult(`Large Array (1k items) Parse (${ITERATIONS_ARRAY} ops)`, tstdlArr, zodArr);
+// 5. Error Handling (Exceptions)
+// Note: TSTDL creates stack traces by default, Zod does not.
+const ITERATIONS_ERROR = 100_000;
+const tstdlErr = benchmark(ITERATIONS_ERROR, () => {
+    try {
+        tstdlUser.parse(invalidUser);
+    }
+    catch (e) { }
+});
+const zodErr = benchmark(ITERATIONS_ERROR, () => {
+    try {
+        zodUser.parse(invalidUser);
+    }
+    catch (e) { }
+});
+logResult(`Error Handling / Throwing (${ITERATIONS_ERROR} ops)`, tstdlErr, zodErr);
+// 6. Error Handling (TSTDL Fast Errors vs Zod)
+// TSTDL has a 'fastErrors' option which might improve performance by skipping stack traces
+const tstdlErrFast = benchmark(ITERATIONS_ERROR, () => {
+    try {
+        tstdlUser.parse(invalidUser, { fastErrors: true });
+    }
+    catch (e) { }
+});
+logResult(`Error Handling (TSTDL fastErrors=true) (${ITERATIONS_ERROR} ops)`, tstdlErrFast, zodErr);
+function main() {
+}
+Application.run('Test', [
+    provideModule(main),
+    provideConsoleLogTransport(PrettyPrintLogFormatter),
+    provideSignalHandler(),
+]);

package/test6.js

@@ -1,124 +1,33 @@
-import z from 'zod';
-import { Application } from './application/application.js';
-import { provideModule, provideSignalHandler } from './application/providers.js';
-import { PrettyPrintLogFormatter, provideConsoleLogTransport } from './logger/index.js';
-import { array, boolean, literal, number, object, optional, string, union } from './schema/index.js';
 import { benchmark } from './utils/benchmark.js';
-function logResult(name, tstdl, zod) {
-    const faster = tstdl.millisecondsPerOperation < zod.millisecondsPerOperation ? 'TSTDL' : 'Zod';
-    const factor = tstdl.millisecondsPerOperation < zod.millisecondsPerOperation ? zod.millisecondsPerOperation / tstdl.millisecondsPerOperation : tstdl.millisecondsPerOperation / zod.millisecondsPerOperation;
-    console.log(`\n--- ${name} ---`);
-    console.log(`TSTDL: ${tstdl.operationsPerMillisecond.toFixed(2)} ops/ms`);
-    console.log(`Zod:   ${zod.operationsPerMillisecond.toFixed(2)} ops/ms`);
-    console.log(`Result: ${faster} is ${factor.toFixed(2)}x faster`);
-}
-// --- SETUP SCHEMAS ---
-// 1. Primitive Schema
-const tstdlString = string();
-const zodString = z.string();
-// 2. Simple Object
-const tstdlUser = object({
-    name: string(),
-    age: number(),
-    isActive: boolean(),
-});
-const zodUser = z.object({
-    name: z.string(),
-    age: z.number(),
-    isActive: z.boolean(),
-});
-// 3. Complex Nested Schema
-const tstdlComplex = object({
-    id: number(),
-    tags: array(string()),
-    metadata: optional(object({
-        createdAt: number(),
-        source: union(literal('web'), literal('mobile')),
-    })),
-});
-const zodComplex = z.object({
-    id: z.number(),
-    tags: z.array(z.string()),
-    metadata: z.object({
-        createdAt: z.number(),
-        source: z.union([z.literal('web'), z.literal('mobile')]),
-    }).optional(),
-});
-// 4. Large Array
-const tstdlArray = array(number());
-const zodArray = z.array(z.number());
-// --- DATA ---
-const validString = 'Hello World';
-const validUser = {
-    name: 'Alice',
-    age: 30,
-    isActive: true,
-};
-const validComplex = {
-    id: 101,
-    tags: ['admin', 'staff', 'verified'],
-    metadata: {
-        createdAt: 1678900000,
-        source: 'web',
-    },
-};
-const largeArrayData = Array.from({ length: 1000 }, (_, i) => i);
-const invalidUser = {
-    name: 'Bob',
-    age: '30', // Invalid: string instead of number
-    isActive: true,
-};
-// --- RUN BENCHMARKS ---
-console.log('Starting Benchmarks...');
-// 1. Primitive Parsing
-const ITERATIONS_PRIMITIVE = 1_000_000;
-const zodPrim = benchmark(ITERATIONS_PRIMITIVE, () => zodString.parse(validString));
-const tstdlPrim = benchmark(ITERATIONS_PRIMITIVE, () => tstdlString.parse(validString));
-logResult(`Primitive String Parse (${ITERATIONS_PRIMITIVE} ops)`, tstdlPrim, zodPrim);
-// 2. Simple Object Parsing
-const ITERATIONS_OBJ = 500_000;
-const zodObj = benchmark(ITERATIONS_OBJ, () => zodUser.parse(validUser));
-const tstdlObj = benchmark(ITERATIONS_OBJ, () => tstdlUser.parse(validUser));
-logResult(`Simple Object Parse (${ITERATIONS_OBJ} ops)`, tstdlObj, zodObj);
-// 3. Complex Nested Object Parsing
-const ITERATIONS_COMPLEX = 200_000;
-const zodCmplx = benchmark(ITERATIONS_COMPLEX, () => zodComplex.parse(validComplex));
-const tstdlCmplx = benchmark(ITERATIONS_COMPLEX, () => tstdlComplex.parse(validComplex));
-logResult(`Complex Object Parse (${ITERATIONS_COMPLEX} ops)`, tstdlCmplx, zodCmplx);
-// 4. Large Array Parsing
-const ITERATIONS_ARRAY = 5_000;
-const zodArr = benchmark(ITERATIONS_ARRAY, () => zodArray.parse(largeArrayData));
-const tstdlArr = benchmark(ITERATIONS_ARRAY, () => tstdlArray.parse(largeArrayData));
-logResult(`Large Array (1k items) Parse (${ITERATIONS_ARRAY} ops)`, tstdlArr, zodArr);
-// 5. Error Handling (Exceptions)
-// Note: TSTDL creates stack traces by default, Zod does not.
-const ITERATIONS_ERROR = 100_000;
-const tstdlErr = benchmark(ITERATIONS_ERROR, () => {
-    try {
-        tstdlUser.parse(invalidUser);
-    }
-    catch (e) { }
-});
-const zodErr = benchmark(ITERATIONS_ERROR, () => {
-    try {
-        zodUser.parse(invalidUser);
+import { isDefined } from './utils/type-guards.js';
+const numberFormatterMap = new Map();
+function getNumberFormatter1(locale, options) {
+    const key = JSON.stringify({ locale, ...options });
+    const existing = numberFormatterMap.get(key);
+    if (isDefined(existing)) {
+        return existing;
     }
-    catch (e) { }
-});
-logResult(`Error Handling / Throwing (${ITERATIONS_ERROR} ops)`, tstdlErr, zodErr);
-// 6. Error Handling (TSTDL Fast Errors vs Zod)
-// TSTDL has a 'fastErrors' option which might improve performance by skipping stack traces
-const tstdlErrFast = benchmark(ITERATIONS_ERROR, () => {
-    try {
-        tstdlUser.parse(invalidUser, { fastErrors: true });
+    const formatter = new Intl.NumberFormat(locale, options);
+    numberFormatterMap.set(key, formatter);
+    return formatter;
+}
+function getNumberFormatter2(locale, options) {
+    const key = JSON.stringify({ locale, options });
+    const existing = numberFormatterMap.get(key);
+    if (isDefined(existing)) {
+        return existing;
     }
-    catch (e) { }
-});
-logResult(`Error Handling (TSTDL fastErrors=true) (${ITERATIONS_ERROR} ops)`, tstdlErrFast, zodErr);
-function main() {
+    const formatter = new Intl.NumberFormat(locale, options);
+    numberFormatterMap.set(key, formatter);
+    return formatter;
+}
+function format1(value, locale, format) {
+    return getNumberFormatter1(locale, format).format(value);
+}
+function format2(value, locale, format) {
+    return getNumberFormatter2(locale, format).format(value);
 }
-Application.run('Test', [
-    provideModule(main),
-    provideConsoleLogTransport(PrettyPrintLogFormatter),
-    provideSignalHandler(),
-]);
+const result1 = benchmark(200000, (run) => format1(run, 'en-US', { maximumFractionDigits: 2 }));
+const result2 = benchmark(200000, (run) => format2(run, 'en-US', { maximumFractionDigits: 2 }));
+console.log(`format:         ${result1.operationsPerMillisecond.toFixed(2)} ops/ms`);
+console.log(`formatCached:   ${result2.operationsPerMillisecond.toFixed(2)} ops/ms`);