@tstdl/base 0.90.11 → 0.90.12

package/intl/number-parser.d.ts

@@ -0,0 +1,18 @@
+export declare class NumberParser {
+    private readonly group;
+    private readonly decimal;
+    private readonly numeral;
+    private readonly loosePattern;
+    private readonly numeralIndex;
+    private readonly numeralReplacer;
+    readonly locale: string;
+    constructor(locale: string);
+    /**
+     * Parse a string
+     * @param value Value to parse
+     * @param loose Try to parse an invalid string by removing unsupported characters. Might produce incorrect results, depending on input
+     */
+    parse(value: string, loose?: boolean): number;
+}
+export declare const getNumberParser: (locale: string) => NumberParser;
+export declare function parseNumber(locale: string, value: string, loose?: boolean): number;

package/intl/number-parser.js

@@ -0,0 +1,41 @@
+import { createArray } from '../utils/array/array.js';
+import { memoizeClassSingle } from '../utils/function/memoize.js';
+export class NumberParser {
+    group;
+    decimal;
+    numeral;
+    loosePattern;
+    numeralIndex;
+    numeralReplacer;
+    locale;
+    constructor(locale) {
+        this.locale = locale;
+        const format = new Intl.NumberFormat(locale);
+        const parts = format.formatToParts(12345.6);
+        const numerals = createArray(10, (i) => format.format(i));
+        const numeralPattern = `[${numerals.join('')}]`;
+        this.numeralIndex = new Map(numerals.map((d, i) => [d, i.toString()]));
+        this.group = parts.find((part) => part.type == 'group').value;
+        this.decimal = parts.find((part) => part.type == 'decimal').value;
+        this.numeral = new RegExp(numeralPattern, 'ug');
+        this.loosePattern = new RegExp(`[^${numerals.join()}${this.group}${this.decimal}]`, 'ug');
+        this.numeralReplacer = (numeral) => this.numeralIndex.get(numeral);
+    }
+    /**
+     * Parse a string
+     * @param value Value to parse
+     * @param loose Try to parse an invalid string by removing unsupported characters. Might produce incorrect results, depending on input
+     */
+    parse(value, loose = false) {
+        const source = loose ? value.replaceAll(this.loosePattern, '') : value;
+        const normalized = source.trim()
+            .replaceAll(this.group, '')
+            .replaceAll(this.decimal, '.')
+            .replaceAll(this.numeral, this.numeralReplacer);
+        return Number(normalized);
+    }
+}
+export const getNumberParser = memoizeClassSingle(NumberParser);
+export function parseNumber(locale, value, loose) {
+    return getNumberParser(locale).parse(value, loose);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.90.11",
+  "version": "0.90.12",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/types.d.ts

@@ -60,8 +60,8 @@ export type EnumerationEntries<T extends EnumerationObject = EnumerationObject>
 export type Type<T = any, Arguments extends any[] = any> = Constructor<T, Arguments> & {
     prototype: T;
 };
-export type Constructor<T = any, Arguments extends any[] = any> = new (...args: Arguments) => T;
-export type AbstractType<T = any, Arguments extends any[] = any> = AbstractConstructor<T, Arguments> & {
+export type Constructor<T = any, Arguments extends any[] = any[]> = new (...args: Arguments) => T;
+export type AbstractType<T = any, Arguments extends any[] = any[]> = AbstractConstructor<T, Arguments> & {
     prototype: T;
 };
 export type AbstractConstructor<T = any, Arguments extends any[] = any> = abstract new (...args: Arguments) => T;

package/utils/function/memoize.d.ts

@@ -1,3 +1,4 @@
+import type { Constructor } from '../../types.js';
 export type MemoizeOptions = {
     /** Use WeakMap instead of Map for caching. Can be used with object parameters only */
     weak?: boolean;
@@ -13,3 +14,5 @@ export type MemoizeOptions = {
  * @returns memoized function
  */
 export declare function memoizeSingle<Fn extends (parameter: any) => any>(fn: Fn, options?: MemoizeOptions): Fn;
+export declare function memoizeClass<T extends Constructor>(type: T, options?: MemoizeOptions): (...parameters: ConstructorParameters<T>) => InstanceType<T>;
+export declare function memoizeClassSingle<T extends Constructor<any, [any]>>(type: T, options?: MemoizeOptions): (...parameters: ConstructorParameters<T>) => InstanceType<T>;

package/utils/function/memoize.js

@@ -37,6 +37,12 @@ export function memoizeSingle(fn, options = {}) {
         }
     }[name];
 }
+export function memoizeClass(type, options = {}) {
+    return memoize((...parameters) => new type(...parameters), options);
+}
+export function memoizeClassSingle(type, options = {}) {
+    return memoizeSingle((parameter) => new type(parameter), options);
+}
 function getMemoizedName(fn) {
     return `memoized${fn.name[0]?.toUpperCase() ?? ''}${fn.name.slice(1)}`;
 }