@develia/commons 0.4.19 → 0.4.21

package/src/string.ts

@@ -26,6 +26,27 @@ export function ensureSuffix(str: string, suffix: string): string {
     return str
 }
 
+/**
+ * Normalizes Unicode whitespaces into single ASCII spaces and removes leading
+ * and trailing whitespace.
+ */
+export function normalizeWhitespaces(str: string): string {
+    return str.normalize('NFKC')
+              .replace(/[\s\u200B\uFEFF]+/gu, ' ')
+              .trim()
+}
+
+/**
+ * Removes Unicode diacritics while preserving the original letter casing.
+ *
+ * @example removeDiacritics('áÁñÑ') // 'aAnN'
+ */
+export function removeDiacritics(str: string): string {
+    return str
+        .normalize('NFD')
+        .replace(/\p{M}+/gu, '')
+}
+
 /**
  * Formats a string using a template and provided arguments.
  *
@@ -129,4 +150,4 @@ export function toPascalCase(str: string): string {
  */
 export function toConstantCase(str: string): string {
     return toWords(str).join('_').toUpperCase();
-}
+}

package/src/types.ts

@@ -2,7 +2,7 @@
 
 export type EqualityComparer<T> = (arg1: T, arg2: T) => boolean;
 
-export type Consumer<T> = (arg: T) => void
+export type Consumer<T> = (arg: T) => void;
 
 export type Predicate<T> = (arg: T) => boolean;
 
@@ -10,8 +10,6 @@ export type Supplier<T> = () => T;
 
 export type Nullable<T> = T | null;
 
-export type Optional<T> = T | undefined;
-
 export type Nullish = null | undefined;
 
 export type Resolvable<T> = T | Promise<T> | Supplier<T>;

package/src/utilities.ts

@@ -6,11 +6,13 @@ import type {Resolvable, Constructor} from "./types.js";
 import Type from "./type.js";
 
 export function lazy<T extends object>(factory: () => T): T {
-    let instance: T | null = null;
+    let created = false;
+    let instance: T;
 
     const getInstance = (): T => {
-        if (!instance) {
+        if (!created) {
             instance = factory();
+            created = true;
         }
         return instance;
     };
@@ -19,8 +21,11 @@ export function lazy<T extends object>(factory: () => T): T {
         get(_, prop, receiver) {
             return Reflect.get(getInstance(), prop, receiver);
         },
-        set(_, prop, value, receiver) {
-            return Reflect.set(getInstance(), prop, value, receiver);
+        set(_, prop, value) {
+            return Reflect.set(getInstance(), prop, value, getInstance());
+        },
+        defineProperty(_, prop, descriptor) {
+            return Reflect.defineProperty(getInstance(), prop, descriptor);
         },
         has(_, prop) {
             return Reflect.has(getInstance(), prop);
@@ -32,7 +37,11 @@ export function lazy<T extends object>(factory: () => T): T {
             return Reflect.ownKeys(getInstance());
         },
         getOwnPropertyDescriptor(_, prop) {
-            return Reflect.getOwnPropertyDescriptor(getInstance(), prop);
+            const descriptor = Reflect.getOwnPropertyDescriptor(getInstance(), prop);
+            if (descriptor == null || descriptor.configurable) {
+                return descriptor;
+            }
+            return {...descriptor, configurable: true};
         },
         getPrototypeOf() {
             return Reflect.getPrototypeOf(getInstance());