@tstdl/base 0.93.68 → 0.93.70

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

@@ -9,11 +9,15 @@ export type LatexRenderOptions = {
 /**
  * Renders LaTeX source code to a PDF file.
  *
+ * ## WARNING
+ * **This function should not be used with untrusted LaTeX source, as it can lead to arbitrary code execution on the system.**
+ *
  * Requires latexmk and LuaTeX to be installed on the system.
  *
  * **Minimal recommendation:**
  * - **Arch Linux:** texlive-binextra texlive-luatex texlive-latexrecommended texlive-fontsrecommended
  * @param source The LaTeX source code to render
+ * @param options Rendering options
  * @returns A TemporaryFile representing the generated PDF
  */
 export declare function renderLatex(source: string, options?: LatexRenderOptions): Promise<TemporaryFile>;

package/latex/render.js

@@ -51,7 +51,8 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
 import { TemporaryFile } from '../file/server/temporary-file.js';
-import { spawnCommand, spawnWaitCommand } from '../process/spawn.js';
+import { spawnWaitCommand, spawnWaitReadCommand } from '../process/spawn.js';
+import { withTimeout } from '../utils/timing.js';
 import { tryIgnoreAsync } from '../utils/try-ignore.js';
 const engineMapping = {
     pdflatex: '-pdflatex',
@@ -61,11 +62,15 @@ const engineMapping = {
 /**
  * Renders LaTeX source code to a PDF file.
  *
+ * ## WARNING
+ * **This function should not be used with untrusted LaTeX source, as it can lead to arbitrary code execution on the system.**
+ *
  * Requires latexmk and LuaTeX to be installed on the system.
  *
  * **Minimal recommendation:**
  * - **Arch Linux:** texlive-binextra texlive-luatex texlive-latexrecommended texlive-fontsrecommended
  * @param source The LaTeX source code to render
+ * @param options Rendering options
  * @returns A TemporaryFile representing the generated PDF
  */
 export async function renderLatex(source, options) {
@@ -73,14 +78,16 @@ export async function renderLatex(source, options) {
     try {
         const latexFile = __addDisposableResource(env_1, await TemporaryFile.from(source, '.tex'), true);
         const engineFlag = engineMapping[options?.engine ?? 'lualatex'];
-        const process = await spawnCommand('latexmk', ['-interaction=nonstopmode', engineFlag, '-cd', latexFile.path]);
-        console.log(latexFile.path);
-        const { code } = await process.wait();
-        if (code != 0) {
-            const [out, err] = await Promise.all([process.readOutput(), process.readError()]);
-            throw new Error(`LaTeX compilation failed with exit code ${code}. Output:\n${out}\nError Output:\n${err}`);
+        const { code, output, error } = await spawnWaitReadCommand('string', 'latexmk', ['-interaction=nonstopmode', engineFlag, '-cd', latexFile.path], { throwOnNonZeroExitCode: false });
+        await tryIgnoreAsync(async () => await withTimeout(1000, spawnWaitCommand('latexmk', ['-c', '-cd', engineFlag, latexFile.path])));
+        if (code !== 0) {
+            throw new Error(`
+LaTeX compilation failed with exit code ${code}.\n
+File: ${latexFile.path}\n
+Output:\n${output}\n
+Error Output:\n${error}
+`.trim());
         }
-        await tryIgnoreAsync(async () => await spawnWaitCommand('latexmk', ['-interaction=nonstopmode', '-pdflua', '-cd', '-c', latexFile.path]));
         return TemporaryFile.adopt(`${latexFile.path.slice(0, -4)}.pdf`);
     }
     catch (e_1) {

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.68",
+  "version": "0.93.70",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -142,7 +142,7 @@
   "peerDependencies": {
     "@genkit-ai/google-genai": "^1.25",
     "@google-cloud/storage": "^7.18",
-    "@google/genai": "^1.32",
+    "@google/genai": "^1.33",
     "@toon-format/toon": "^2.1.0",
     "@tstdl/angular": "^0.93",
     "@zxcvbn-ts/core": "^3.0",
@@ -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/process/spawn.d.ts

@@ -1,12 +1,18 @@
 import type { ChildProcessWithoutNullStreams } from 'node:child_process';
 import type { Record } from '../types/types.js';
+type WaitReadResultFormat = 'string' | 'binary';
+type WaitReadResultFormatType<T extends WaitReadResultFormat> = T extends 'string' ? string : Uint8Array<ArrayBuffer>;
 export type WaitOptions = {
     throwOnNonZeroExitCode?: boolean;
 };
-export type ProcessResult = {
+export type WaitResult = {
     code: number | null;
     signal: string | null;
 };
+export type WaitReadResult<Format extends WaitReadResultFormat> = WaitResult & {
+    output: WaitReadResultFormatType<Format>;
+    error: WaitReadResultFormatType<Format>;
+};
 export type SpawnOptions = {
     arguments?: string[];
     workingDirectory?: string;
@@ -22,11 +28,16 @@ export type SpawnCommandResult = TransformStream<Uint8Array, Uint8Array> & {
     readErrorBytes(): Promise<Uint8Array>;
     readError(): Promise<string>;
     handleNonZeroExitCode(): void;
-    wait(options?: WaitOptions): Promise<ProcessResult>;
+    wait(options?: WaitOptions): Promise<WaitResult>;
+    waitRead<F extends WaitReadResultFormat>(format: F, options?: WaitOptions): Promise<WaitReadResult<F>>;
 };
 /** spwans a command and waits for it to complete */
-export declare function spawnWaitCommand(command: string, args?: string[], options?: SpawnOptions & WaitOptions): Promise<ProcessResult>;
-export declare function spawnWaitCommand(command: string, options?: SpawnOptions & WaitOptions): Promise<ProcessResult>;
+export declare function spawnWaitCommand(command: string, args?: string[], options?: SpawnOptions & WaitOptions): Promise<WaitResult>;
+export declare function spawnWaitCommand(command: string, options?: SpawnOptions & WaitOptions): Promise<WaitResult>;
+/** spwans a command, waits for it to complete and reads its output */
+export declare function spawnWaitReadCommand<F extends WaitReadResultFormat>(format: F, command: string, args?: string[], options?: SpawnOptions & WaitOptions): Promise<WaitReadResult<F>>;
+export declare function spawnWaitReadCommand<F extends WaitReadResultFormat>(format: F, command: string, options?: SpawnOptions & WaitOptions): Promise<WaitReadResult<F>>;
 /** Spawns a command as a child process. */
 export declare function spawnCommand(command: string, args?: string[], options?: SpawnOptions): Promise<SpawnCommandResult>;
 export declare function spawnCommand(command: string, options?: SpawnOptions): Promise<SpawnCommandResult>;
+export {};

package/process/spawn.js

@@ -9,6 +9,11 @@ export async function spawnWaitCommand(command, argsOrOptions, optionsOrNothing)
     const process = await spawnCommand(command, args, options);
     return await process.wait({ throwOnNonZeroExitCode: options?.throwOnNonZeroExitCode });
 }
+export async function spawnWaitReadCommand(format, command, argsOrOptions, optionsOrNothing) {
+    const [args, options] = isArray(argsOrOptions) ? [argsOrOptions, optionsOrNothing] : [undefined, argsOrOptions];
+    const process = await spawnCommand(command, args, options);
+    return await process.waitRead(format, { throwOnNonZeroExitCode: options?.throwOnNonZeroExitCode });
+}
 export async function spawnCommand(command, argsOrOptions, optionsOrNothing) {
     const { spawn } = await dynamicImport('node:child_process');
     const { Readable, Writable } = await dynamicImport('node:stream');
@@ -81,6 +86,18 @@ export async function spawnCommand(command, argsOrOptions, optionsOrNothing) {
         }
         return result;
     }
+    async function waitRead(format, { throwOnNonZeroExitCode = true } = {}) {
+        const [result, output, error] = await Promise.all([
+            wait({ throwOnNonZeroExitCode }),
+            (format === 'string') ? readOutput() : readOutputBytes(),
+            (format === 'string') ? readError() : readErrorBytes(),
+        ]);
+        return {
+            ...result,
+            output: output,
+            error: error,
+        };
+    }
     return {
         process,
         readable,
@@ -94,5 +111,6 @@ export async function spawnCommand(command, argsOrOptions, optionsOrNothing) {
         readError,
         handleNonZeroExitCode: () => void handleNonZeroExitCode(),
         wait,
+        waitRead,
     };
 }

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-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`);

package/utils/try-ignore.d.ts

@@ -1,9 +1,9 @@
 import type { Logger } from '../logger/logger.js';
-export declare function tryIgnore<R>(fn: () => R): R;
+export declare function tryIgnore<R>(fn: () => R): R | undefined;
 export declare function tryIgnore<R, F>(fn: () => R, fallback: F): R | F;
-export declare function tryIgnoreAsync<R>(fn: () => Promise<R>): Promise<R>;
+export declare function tryIgnoreAsync<R>(fn: () => Promise<R>): Promise<R | undefined>;
 export declare function tryIgnoreAsync<R, F>(fn: () => Promise<R>, fallback: F): Promise<F>;
-export declare function tryIgnoreLog<R>(logger: Logger, fn: () => R): R;
+export declare function tryIgnoreLog<R>(logger: Logger, fn: () => R): R | undefined;
 export declare function tryIgnoreLog<R, F>(logger: Logger, fn: () => R, fallback: F): R | F;
-export declare function tryIgnoreLogAsync<R>(logger: Logger, fn: () => Promise<R>): Promise<R>;
+export declare function tryIgnoreLogAsync<R>(logger: Logger, fn: () => Promise<R>): Promise<R | undefined>;
 export declare function tryIgnoreLogAsync<R, F>(logger: Logger, fn: () => Promise<R>, fallback: F): Promise<F>;