@rg-dev/stdlib 1.0.23 → 1.0.24

package/lib/common-env.cjs

@@ -96,8 +96,7 @@ var Optional = class _Optional {
     return new _Optional(val);
   }
   orElseThrow(msg) {
-    if (this.value === void 0)
-      throw new Error(msg || "Value is empty");
+    if (this.value === void 0) throw new Error(msg || "Value is empty");
     return this.value;
   }
   setValue(newValue) {
@@ -108,8 +107,7 @@ var Optional = class _Optional {
     return this.value;
   }
   ifPresent(action) {
-    if (this.value === void 0)
-      return;
+    if (this.value === void 0) return;
     try {
       action(this.value);
     } catch (e) {
@@ -149,8 +147,7 @@ async function catchInline(cb) {
 }
 function doSafe(safe, onError) {
   var _a;
-  if (!safe)
-    return;
+  if (!safe) return;
   try {
     const result = safe();
     if (isPromise(result)) {

package/lib/common-env.d.cts

@@ -1,73 +1,73 @@
-type Options = {
-    maxAttempts: number;
-    retryDelay: number;
-    onError: (err: any, attempt: number) => void;
-};
+type Options = {
+    maxAttempts: number;
+    retryDelay: number;
+    onError: (err: any, attempt: number) => void;
+};
 declare function promiseRetry<T>(func: (attempt: number) => Promise<T>, options?: Partial<Options>, attempt?: number): Promise<T>;
 
-interface IStringBuilder {
-    /**
-     * Append the specified text to the buffer.
-     */
-    append(text: string): void;
-    /**
-     * Returns a single string containing all the text that was appended to the buffer so far.
-     *
-     * @remarks
-     *
-     * This is a potentially expensive operation.
-     */
-    toString(): string;
-}
-/**
- * This class allows a large text string to be constructed incrementally by appending small chunks.  The final
- * string can be obtained by calling StringBuilder.toString().
- *
- * @remarks
- * A naive approach might use the `+=` operator to append strings:  This would have the downside of copying
- * the entire string each time a chunk is appended, resulting in `O(n^2)` bytes of memory being allocated
- * (and later freed by the garbage  collector), and many of the allocations could be very large objects.
- * StringBuilder avoids this overhead by accumulating the chunks in an array, and efficiently joining them
- * when `getText()` is finally called.
- *
- * @public
- */
-declare class StringBuilder implements IStringBuilder {
-    private _chunks;
-    constructor();
-    /** {@inheritDoc IStringBuilder.append} */
-    append(text: string): this;
-    /** {@inheritDoc IStringBuilder.toString} */
-    toString(): string;
+interface IStringBuilder {
+    /**
+     * Append the specified text to the buffer.
+     */
+    append(text: string): void;
+    /**
+     * Returns a single string containing all the text that was appended to the buffer so far.
+     *
+     * @remarks
+     *
+     * This is a potentially expensive operation.
+     */
+    toString(): string;
+}
+/**
+ * This class allows a large text string to be constructed incrementally by appending small chunks.  The final
+ * string can be obtained by calling StringBuilder.toString().
+ *
+ * @remarks
+ * A naive approach might use the `+=` operator to append strings:  This would have the downside of copying
+ * the entire string each time a chunk is appended, resulting in `O(n^2)` bytes of memory being allocated
+ * (and later freed by the garbage  collector), and many of the allocations could be very large objects.
+ * StringBuilder avoids this overhead by accumulating the chunks in an array, and efficiently joining them
+ * when `getText()` is finally called.
+ *
+ * @public
+ */
+declare class StringBuilder implements IStringBuilder {
+    private _chunks;
+    constructor();
+    /** {@inheritDoc IStringBuilder.append} */
+    append(text: string): this;
+    /** {@inheritDoc IStringBuilder.toString} */
+    toString(): string;
 }
 
-type MyFn<T extends Record<string, (...args: any[]) => any>> = {
-    [K in keyof T]: (...args: Parameters<T[K]>) => void;
-};
-type AsyncReturnType<T extends (...args: any) => any> = Awaited<ReturnType<T>>;
-type MaybeFunction = ((...args: any) => void) | undefined;
-declare class Optional<T> {
-    private value;
-    private constructor();
-    static of<T>(val: T | any): Optional<T>;
-    orElseThrow(msg?: string): T;
-    setValue(newValue: T): this;
-    getValue(): T | undefined;
-    ifPresent(action: (val: Exclude<T, undefined>) => void): void;
-}
-declare function sleep(ms: number): Promise<unknown>;
-declare function isNumber(num: any): boolean;
-declare function promiseWithTimeout<T>(promise: Promise<T>, timeout: number, errMsg?: string): Promise<T>;
-declare function catchInline<T>(cb: Promise<T>): Promise<{
-    error: undefined;
-    result: T;
-} | {
-    error: Error;
-    result: undefined;
-}>;
-declare function doSafe(safe: () => Promise<void> | void, onError?: (error: Error) => void): void;
-declare function isRunningOnServer(): boolean;
-declare function useServer(fn: () => (Promise<any> | void), onError?: (err: Error) => void): Promise<any>;
+type MyFn<T extends Record<string, (...args: any[]) => any>> = {
+    [K in keyof T]: (...args: Parameters<T[K]>) => void;
+};
+type AsyncReturnType<T extends (...args: any) => any> = Awaited<ReturnType<T>>;
+type MaybeFunction = ((...args: any) => void) | undefined;
+declare class Optional<T> {
+    private value;
+    private constructor();
+    static of<T>(val: T | any): Optional<T>;
+    orElseThrow(msg?: string): T;
+    setValue(newValue: T): this;
+    getValue(): T | undefined;
+    ifPresent(action: (val: Exclude<T, undefined>) => void): void;
+}
+declare function sleep(ms: number): Promise<unknown>;
+declare function isNumber(num: any): boolean;
+declare function promiseWithTimeout<T>(promise: Promise<T>, timeout: number, errMsg?: string): Promise<T>;
+declare function catchInline<T>(cb: Promise<T>): Promise<{
+    error: undefined;
+    result: T;
+} | {
+    error: Error;
+    result: undefined;
+}>;
+declare function doSafe(safe: () => Promise<void> | void, onError?: (error: Error) => void): void;
+declare function isRunningOnServer(): boolean;
+declare function useServer(fn: () => (Promise<any> | void), onError?: (err: Error) => void): Promise<any>;
 declare function isNonEmptyString(str?: string): boolean;
 
 export { type AsyncReturnType, type MaybeFunction, type MyFn, Optional, StringBuilder, catchInline, doSafe, isNonEmptyString, isNumber, isRunningOnServer, promiseRetry, promiseWithTimeout, sleep, useServer };

package/lib/common-env.d.ts

@@ -1,73 +1,73 @@
-type Options = {
-    maxAttempts: number;
-    retryDelay: number;
-    onError: (err: any, attempt: number) => void;
-};
+type Options = {
+    maxAttempts: number;
+    retryDelay: number;
+    onError: (err: any, attempt: number) => void;
+};
 declare function promiseRetry<T>(func: (attempt: number) => Promise<T>, options?: Partial<Options>, attempt?: number): Promise<T>;
 
-interface IStringBuilder {
-    /**
-     * Append the specified text to the buffer.
-     */
-    append(text: string): void;
-    /**
-     * Returns a single string containing all the text that was appended to the buffer so far.
-     *
-     * @remarks
-     *
-     * This is a potentially expensive operation.
-     */
-    toString(): string;
-}
-/**
- * This class allows a large text string to be constructed incrementally by appending small chunks.  The final
- * string can be obtained by calling StringBuilder.toString().
- *
- * @remarks
- * A naive approach might use the `+=` operator to append strings:  This would have the downside of copying
- * the entire string each time a chunk is appended, resulting in `O(n^2)` bytes of memory being allocated
- * (and later freed by the garbage  collector), and many of the allocations could be very large objects.
- * StringBuilder avoids this overhead by accumulating the chunks in an array, and efficiently joining them
- * when `getText()` is finally called.
- *
- * @public
- */
-declare class StringBuilder implements IStringBuilder {
-    private _chunks;
-    constructor();
-    /** {@inheritDoc IStringBuilder.append} */
-    append(text: string): this;
-    /** {@inheritDoc IStringBuilder.toString} */
-    toString(): string;
+interface IStringBuilder {
+    /**
+     * Append the specified text to the buffer.
+     */
+    append(text: string): void;
+    /**
+     * Returns a single string containing all the text that was appended to the buffer so far.
+     *
+     * @remarks
+     *
+     * This is a potentially expensive operation.
+     */
+    toString(): string;
+}
+/**
+ * This class allows a large text string to be constructed incrementally by appending small chunks.  The final
+ * string can be obtained by calling StringBuilder.toString().
+ *
+ * @remarks
+ * A naive approach might use the `+=` operator to append strings:  This would have the downside of copying
+ * the entire string each time a chunk is appended, resulting in `O(n^2)` bytes of memory being allocated
+ * (and later freed by the garbage  collector), and many of the allocations could be very large objects.
+ * StringBuilder avoids this overhead by accumulating the chunks in an array, and efficiently joining them
+ * when `getText()` is finally called.
+ *
+ * @public
+ */
+declare class StringBuilder implements IStringBuilder {
+    private _chunks;
+    constructor();
+    /** {@inheritDoc IStringBuilder.append} */
+    append(text: string): this;
+    /** {@inheritDoc IStringBuilder.toString} */
+    toString(): string;
 }
 
-type MyFn<T extends Record<string, (...args: any[]) => any>> = {
-    [K in keyof T]: (...args: Parameters<T[K]>) => void;
-};
-type AsyncReturnType<T extends (...args: any) => any> = Awaited<ReturnType<T>>;
-type MaybeFunction = ((...args: any) => void) | undefined;
-declare class Optional<T> {
-    private value;
-    private constructor();
-    static of<T>(val: T | any): Optional<T>;
-    orElseThrow(msg?: string): T;
-    setValue(newValue: T): this;
-    getValue(): T | undefined;
-    ifPresent(action: (val: Exclude<T, undefined>) => void): void;
-}
-declare function sleep(ms: number): Promise<unknown>;
-declare function isNumber(num: any): boolean;
-declare function promiseWithTimeout<T>(promise: Promise<T>, timeout: number, errMsg?: string): Promise<T>;
-declare function catchInline<T>(cb: Promise<T>): Promise<{
-    error: undefined;
-    result: T;
-} | {
-    error: Error;
-    result: undefined;
-}>;
-declare function doSafe(safe: () => Promise<void> | void, onError?: (error: Error) => void): void;
-declare function isRunningOnServer(): boolean;
-declare function useServer(fn: () => (Promise<any> | void), onError?: (err: Error) => void): Promise<any>;
+type MyFn<T extends Record<string, (...args: any[]) => any>> = {
+    [K in keyof T]: (...args: Parameters<T[K]>) => void;
+};
+type AsyncReturnType<T extends (...args: any) => any> = Awaited<ReturnType<T>>;
+type MaybeFunction = ((...args: any) => void) | undefined;
+declare class Optional<T> {
+    private value;
+    private constructor();
+    static of<T>(val: T | any): Optional<T>;
+    orElseThrow(msg?: string): T;
+    setValue(newValue: T): this;
+    getValue(): T | undefined;
+    ifPresent(action: (val: Exclude<T, undefined>) => void): void;
+}
+declare function sleep(ms: number): Promise<unknown>;
+declare function isNumber(num: any): boolean;
+declare function promiseWithTimeout<T>(promise: Promise<T>, timeout: number, errMsg?: string): Promise<T>;
+declare function catchInline<T>(cb: Promise<T>): Promise<{
+    error: undefined;
+    result: T;
+} | {
+    error: Error;
+    result: undefined;
+}>;
+declare function doSafe(safe: () => Promise<void> | void, onError?: (error: Error) => void): void;
+declare function isRunningOnServer(): boolean;
+declare function useServer(fn: () => (Promise<any> | void), onError?: (err: Error) => void): Promise<any>;
 declare function isNonEmptyString(str?: string): boolean;
 
 export { type AsyncReturnType, type MaybeFunction, type MyFn, Optional, StringBuilder, catchInline, doSafe, isNonEmptyString, isNumber, isRunningOnServer, promiseRetry, promiseWithTimeout, sleep, useServer };

package/lib/common-env.js

@@ -61,8 +61,7 @@ var Optional = class _Optional {
     return new _Optional(val);
   }
   orElseThrow(msg) {
-    if (this.value === void 0)
-      throw new Error(msg || "Value is empty");
+    if (this.value === void 0) throw new Error(msg || "Value is empty");
     return this.value;
   }
   setValue(newValue) {
@@ -73,8 +72,7 @@ var Optional = class _Optional {
     return this.value;
   }
   ifPresent(action) {
-    if (this.value === void 0)
-      return;
+    if (this.value === void 0) return;
     try {
       action(this.value);
     } catch (e) {
@@ -114,8 +112,7 @@ async function catchInline(cb) {
 }
 function doSafe(safe, onError) {
   var _a;
-  if (!safe)
-    return;
+  if (!safe) return;
   try {
     const result = safe();
     if (isPromise(result)) {