@naturalcycles/js-lib 14.252.0 → 14.253.0

package/dist/error/assert.d.ts

@@ -1,5 +1,4 @@
-import type { ErrorData, ErrorObject } from '..';
-import { Class } from '..';
+import { BackendErrorResponseObject, Class, ErrorData, ErrorObject } from '..';
 /**
  * Evaluates the `condition` (casts it to Boolean).
  * Expects it to be truthy, otherwise throws AppError.
@@ -40,6 +39,7 @@ export declare function _assertIsError<ERR extends Error = Error>(err: any, erro
  */
 export declare function _assertErrorClassOrRethrow<ERR extends Error>(err: any, errorClass: Class<ERR>): asserts err is ERR;
 export declare function _assertIsErrorObject<DATA_TYPE extends ErrorData = ErrorData>(obj: any): asserts obj is ErrorObject<DATA_TYPE>;
+export declare function _assertIsBackendErrorResponseObject<DATA_TYPE extends ErrorData = ErrorData>(obj: any): asserts obj is BackendErrorResponseObject<DATA_TYPE>;
 export declare function _assertIsString(v: any, message?: string): asserts v is string;
 export declare function _assertIsNumber(v: any, message?: string): asserts v is number;
 export declare function _assertTypeOf<T>(v: any, expectedType: string, message?: string): asserts v is T;

package/dist/error/assert.js

@@ -6,6 +6,7 @@ exports._assertDeepEquals = _assertDeepEquals;
 exports._assertIsError = _assertIsError;
 exports._assertErrorClassOrRethrow = _assertErrorClassOrRethrow;
 exports._assertIsErrorObject = _assertIsErrorObject;
+exports._assertIsBackendErrorResponseObject = _assertIsBackendErrorResponseObject;
 exports._assertIsString = _assertIsString;
 exports._assertIsNumber = _assertIsNumber;
 exports._assertTypeOf = _assertTypeOf;
@@ -89,6 +90,11 @@ function _assertIsErrorObject(obj) {
         throw new __1.AssertionError(`Expected to be ErrorObject, actual typeof: ${typeof obj}`);
     }
 }
+function _assertIsBackendErrorResponseObject(obj) {
+    if (!(0, __1._isBackendErrorResponseObject)(obj)) {
+        throw new __1.AssertionError(`Expected to be BackendErrorResponseObject, actual typeof: ${typeof obj}`);
+    }
+}
 function _assertIsString(v, message) {
     _assertTypeOf(v, 'string', message);
 }

package/dist/http/fetcher.js

@@ -320,23 +320,32 @@ class Fetcher {
     }
     async onNotOkResponse(res) {
         let cause;
+        // Try to fetch body and attach to res.body
+        // (but don't fail if it doesn't work)
+        if (!res.body && res.fetchResponse) {
+            try {
+                res.body = (0, json_util_1._jsonParseIfPossible)(await res.fetchResponse.text());
+            }
+            catch {
+                // ignore body fetching/parsing errors at this point
+            }
+        }
         if (res.err) {
             // This is only possible on JSON.parse error, or CORS error,
             // or `unexpected redirect`
             // This check should go first, to avoid calling .text() twice (which will fail)
             cause = (0, error_util_1._errorLikeToErrorObject)(res.err);
         }
-        else if (res.fetchResponse) {
-            const body = (0, json_util_1._jsonParseIfPossible)(await res.fetchResponse.text());
-            if (body) {
-                cause = (0, error_util_1._anyToErrorObject)(body);
-            }
+        else if (res.body) {
+            cause = (0, error_util_1._anyToErrorObject)(res.body);
+        }
+        else {
+            cause = {
+                name: 'Error',
+                message: 'Fetch failed',
+                data: {},
+            };
         }
-        cause ||= {
-            name: 'Error',
-            message: 'Fetch failed',
-            data: {},
-        };
         let responseStatusCode = res.fetchResponse?.status || 0;
         if (res.statusFamily === 2) {
             // important to reset responseStatusCode to 0 in this case, as status 2xx can be misleading

package/dist/index.d.ts

@@ -74,6 +74,7 @@ export * from './string/pupa';
 export * from './string/readingTime';
 export * from './string/regex';
 export * from './string/safeJsonStringify';
+export * from './string/slugify';
 export * from './string/string.util';
 export * from './string/stringify';
 export * from './string/url.util';

package/dist/index.js

@@ -78,6 +78,7 @@ tslib_1.__exportStar(require("./string/pupa"), exports);
 tslib_1.__exportStar(require("./string/readingTime"), exports);
 tslib_1.__exportStar(require("./string/regex"), exports);
 tslib_1.__exportStar(require("./string/safeJsonStringify"), exports);
+tslib_1.__exportStar(require("./string/slugify"), exports);
 tslib_1.__exportStar(require("./string/string.util"), exports);
 tslib_1.__exportStar(require("./string/stringify"), exports);
 tslib_1.__exportStar(require("./string/url.util"), exports);

package/dist/string/slugify.d.ts

@@ -0,0 +1,19 @@
+export interface SlugifyOptions {
+    /**
+     * Default: `-`
+     */
+    separator?: string;
+    /**
+     * Default: true
+     */
+    lowercase?: boolean;
+    /**
+     * Default: true
+     */
+    decamelize?: boolean;
+    /**
+     * Default: []
+     */
+    preserveCharacters?: string[];
+}
+export declare function _slugify(s: string, opt?: SlugifyOptions): string;

package/dist/string/slugify.js

@@ -0,0 +1,69 @@
+"use strict";
+// Credit to (adopted from): https://github.com/sindresorhus/slugify/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._slugify = _slugify;
+function _slugify(s, opt = {}) {
+    opt = {
+        separator: '-',
+        lowercase: true,
+        decamelize: true,
+        preserveCharacters: [],
+        ...opt,
+    };
+    if (opt.decamelize) {
+        s = decamelize(s);
+    }
+    const patternSlug = buildPatternSlug(opt);
+    if (opt.lowercase) {
+        s = s.toLowerCase();
+    }
+    // based on https://stackoverflow.com/a/23633850/4919972
+    // Combining Diacritical Marks
+    // https://www.unicode.org/charts/PDF/U0300.pdf
+    // biome-ignore lint/suspicious/noMisleadingCharacterClass: ok
+    s = s.normalize('NFKD').replaceAll(/[\u0300-\u036F]/g, '');
+    // Detect contractions/possessives by looking for any word followed by a `'t`
+    // or `'s` in isolation and then remove it.
+    s = s.replaceAll(/([a-zA-Z\d]+)'([ts])(\s|$)/g, '$1$2$3');
+    s = s.replace(patternSlug, opt.separator);
+    s = s.replaceAll('\\', '');
+    if (opt.separator) {
+        s = removeMootSeparators(s, opt.separator);
+    }
+    return s;
+}
+function buildPatternSlug(options) {
+    let negationSetPattern = String.raw `a-z\d`;
+    negationSetPattern += options.lowercase ? '' : 'A-Z';
+    if (options.preserveCharacters.length > 0) {
+        for (const character of options.preserveCharacters) {
+            if (character === options.separator) {
+                throw new Error(`The separator character \`${options.separator}\` cannot be included in preserved characters: ${options.preserveCharacters}`);
+            }
+            negationSetPattern += escapeStringRegexp(character);
+        }
+    }
+    return new RegExp(`[^${negationSetPattern}]+`, 'g');
+}
+function removeMootSeparators(s, separator) {
+    const escapedSeparator = escapeStringRegexp(separator);
+    return s
+        .replaceAll(new RegExp(`${escapedSeparator}{2,}`, 'g'), separator)
+        .replaceAll(new RegExp(`^${escapedSeparator}|${escapedSeparator}$`, 'g'), '');
+}
+function decamelize(s) {
+    return (s
+        // Separate capitalized words.
+        .replaceAll(/([A-Z]{2,})(\d+)/g, '$1 $2')
+        .replaceAll(/([a-z\d]+)([A-Z]{2,})/g, '$1 $2')
+        .replaceAll(/([a-z\d])([A-Z])/g, '$1 $2')
+        // `[a-rt-z]` matches all lowercase characters except `s`.
+        // This avoids matching plural acronyms like `APIs`.
+        .replaceAll(/([A-Z]+)([A-Z][a-rt-z\d]+)/g, '$1 $2'));
+}
+// based on: https://github.com/sindresorhus/escape-string-regexp/
+function escapeStringRegexp(s) {
+    // Escape characters with special meaning either inside or outside character sets.
+    // Use a simple backslash escape when it’s always valid, and a `\xnn` escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.
+    return s.replaceAll(/[|\\{}()[\]^$+*?.]/g, String.raw `\$&`).replaceAll('-', String.raw `\x2d`);
+}

package/dist-esm/error/assert.js

@@ -1,4 +1,4 @@
-import { _deepEquals, _isErrorObject, _stringify, AssertionError } from '..';
+import { _deepEquals, _isBackendErrorResponseObject, _isErrorObject, _stringify, AssertionError, } from '..';
 /**
  * Evaluates the `condition` (casts it to Boolean).
  * Expects it to be truthy, otherwise throws AppError.
@@ -78,6 +78,11 @@ export function _assertIsErrorObject(obj) {
         throw new AssertionError(`Expected to be ErrorObject, actual typeof: ${typeof obj}`);
     }
 }
+export function _assertIsBackendErrorResponseObject(obj) {
+    if (!_isBackendErrorResponseObject(obj)) {
+        throw new AssertionError(`Expected to be BackendErrorResponseObject, actual typeof: ${typeof obj}`);
+    }
+}
 export function _assertIsString(v, message) {
     _assertTypeOf(v, 'string', message);
 }

package/dist-esm/http/fetcher.js

@@ -312,23 +312,32 @@ export class Fetcher {
     }
     async onNotOkResponse(res) {
         let cause;
+        // Try to fetch body and attach to res.body
+        // (but don't fail if it doesn't work)
+        if (!res.body && res.fetchResponse) {
+            try {
+                res.body = _jsonParseIfPossible(await res.fetchResponse.text());
+            }
+            catch {
+                // ignore body fetching/parsing errors at this point
+            }
+        }
         if (res.err) {
             // This is only possible on JSON.parse error, or CORS error,
             // or `unexpected redirect`
             // This check should go first, to avoid calling .text() twice (which will fail)
             cause = _errorLikeToErrorObject(res.err);
         }
-        else if (res.fetchResponse) {
-            const body = _jsonParseIfPossible(await res.fetchResponse.text());
-            if (body) {
-                cause = _anyToErrorObject(body);
-            }
+        else if (res.body) {
+            cause = _anyToErrorObject(res.body);
+        }
+        else {
+            cause = {
+                name: 'Error',
+                message: 'Fetch failed',
+                data: {},
+            };
         }
-        cause || (cause = {
-            name: 'Error',
-            message: 'Fetch failed',
-            data: {},
-        });
         let responseStatusCode = res.fetchResponse?.status || 0;
         if (res.statusFamily === 2) {
             // important to reset responseStatusCode to 0 in this case, as status 2xx can be misleading

package/dist-esm/index.js

@@ -74,6 +74,7 @@ export * from './string/pupa';
 export * from './string/readingTime';
 export * from './string/regex';
 export * from './string/safeJsonStringify';
+export * from './string/slugify';
 export * from './string/string.util';
 export * from './string/stringify';
 export * from './string/url.util';

package/dist-esm/string/slugify.js

@@ -0,0 +1,66 @@
+// Credit to (adopted from): https://github.com/sindresorhus/slugify/
+export function _slugify(s, opt = {}) {
+    opt = {
+        separator: '-',
+        lowercase: true,
+        decamelize: true,
+        preserveCharacters: [],
+        ...opt,
+    };
+    if (opt.decamelize) {
+        s = decamelize(s);
+    }
+    const patternSlug = buildPatternSlug(opt);
+    if (opt.lowercase) {
+        s = s.toLowerCase();
+    }
+    // based on https://stackoverflow.com/a/23633850/4919972
+    // Combining Diacritical Marks
+    // https://www.unicode.org/charts/PDF/U0300.pdf
+    // biome-ignore lint/suspicious/noMisleadingCharacterClass: ok
+    s = s.normalize('NFKD').replaceAll(/[\u0300-\u036F]/g, '');
+    // Detect contractions/possessives by looking for any word followed by a `'t`
+    // or `'s` in isolation and then remove it.
+    s = s.replaceAll(/([a-zA-Z\d]+)'([ts])(\s|$)/g, '$1$2$3');
+    s = s.replace(patternSlug, opt.separator);
+    s = s.replaceAll('\\', '');
+    if (opt.separator) {
+        s = removeMootSeparators(s, opt.separator);
+    }
+    return s;
+}
+function buildPatternSlug(options) {
+    let negationSetPattern = String.raw `a-z\d`;
+    negationSetPattern += options.lowercase ? '' : 'A-Z';
+    if (options.preserveCharacters.length > 0) {
+        for (const character of options.preserveCharacters) {
+            if (character === options.separator) {
+                throw new Error(`The separator character \`${options.separator}\` cannot be included in preserved characters: ${options.preserveCharacters}`);
+            }
+            negationSetPattern += escapeStringRegexp(character);
+        }
+    }
+    return new RegExp(`[^${negationSetPattern}]+`, 'g');
+}
+function removeMootSeparators(s, separator) {
+    const escapedSeparator = escapeStringRegexp(separator);
+    return s
+        .replaceAll(new RegExp(`${escapedSeparator}{2,}`, 'g'), separator)
+        .replaceAll(new RegExp(`^${escapedSeparator}|${escapedSeparator}$`, 'g'), '');
+}
+function decamelize(s) {
+    return (s
+        // Separate capitalized words.
+        .replaceAll(/([A-Z]{2,})(\d+)/g, '$1 $2')
+        .replaceAll(/([a-z\d]+)([A-Z]{2,})/g, '$1 $2')
+        .replaceAll(/([a-z\d])([A-Z])/g, '$1 $2')
+        // `[a-rt-z]` matches all lowercase characters except `s`.
+        // This avoids matching plural acronyms like `APIs`.
+        .replaceAll(/([A-Z]+)([A-Z][a-rt-z\d]+)/g, '$1 $2'));
+}
+// based on: https://github.com/sindresorhus/escape-string-regexp/
+function escapeStringRegexp(s) {
+    // Escape characters with special meaning either inside or outside character sets.
+    // Use a simple backslash escape when it’s always valid, and a `\xnn` escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.
+    return s.replaceAll(/[|\\{}()[\]^$+*?.]/g, String.raw `\$&`).replaceAll('-', String.raw `\x2d`);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/js-lib",
-  "version": "14.252.0",
+  "version": "14.253.0",
   "scripts": {
     "prepare": "husky",
     "build": "dev-lib build-esm-cjs",

package/src/error/assert.ts

@@ -1,5 +1,14 @@
-import type { ErrorData, ErrorObject } from '..'
-import { _deepEquals, _isErrorObject, _stringify, AssertionError, Class } from '..'
+import {
+  _deepEquals,
+  _isBackendErrorResponseObject,
+  _isErrorObject,
+  _stringify,
+  AssertionError,
+  BackendErrorResponseObject,
+  Class,
+  ErrorData,
+  ErrorObject,
+} from '..'
 
 /**
  * Evaluates the `condition` (casts it to Boolean).
@@ -113,6 +122,16 @@ export function _assertIsErrorObject<DATA_TYPE extends ErrorData = ErrorData>(
   }
 }
 
+export function _assertIsBackendErrorResponseObject<DATA_TYPE extends ErrorData = ErrorData>(
+  obj: any,
+): asserts obj is BackendErrorResponseObject<DATA_TYPE> {
+  if (!_isBackendErrorResponseObject(obj)) {
+    throw new AssertionError(
+      `Expected to be BackendErrorResponseObject, actual typeof: ${typeof obj}`,
+    )
+  }
+}
+
 export function _assertIsString(v: any, message?: string): asserts v is string {
   _assertTypeOf<string>(v, 'string', message)
 }

package/src/http/fetcher.ts

@@ -416,24 +416,31 @@ export class Fetcher {
   private async onNotOkResponse(res: FetcherResponse): Promise<void> {
     let cause: ErrorObject
 
+    // Try to fetch body and attach to res.body
+    // (but don't fail if it doesn't work)
+    if (!res.body && res.fetchResponse) {
+      try {
+        res.body = _jsonParseIfPossible(await res.fetchResponse.text())
+      } catch {
+        // ignore body fetching/parsing errors at this point
+      }
+    }
+
     if (res.err) {
       // This is only possible on JSON.parse error, or CORS error,
       // or `unexpected redirect`
       // This check should go first, to avoid calling .text() twice (which will fail)
       cause = _errorLikeToErrorObject(res.err)
-    } else if (res.fetchResponse) {
-      const body = _jsonParseIfPossible(await res.fetchResponse.text())
-      if (body) {
-        cause = _anyToErrorObject(body)
+    } else if (res.body) {
+      cause = _anyToErrorObject(res.body)
+    } else {
+      cause = {
+        name: 'Error',
+        message: 'Fetch failed',
+        data: {},
       }
     }
 
-    cause ||= {
-      name: 'Error',
-      message: 'Fetch failed',
-      data: {},
-    }
-
     let responseStatusCode = res.fetchResponse?.status || 0
     if (res.statusFamily === 2) {
       // important to reset responseStatusCode to 0 in this case, as status 2xx can be misleading

package/src/index.ts

@@ -74,6 +74,7 @@ export * from './string/pupa'
 export * from './string/readingTime'
 export * from './string/regex'
 export * from './string/safeJsonStringify'
+export * from './string/slugify'
 export * from './string/string.util'
 export * from './string/stringify'
 export * from './string/url.util'

package/src/string/slugify.ts

@@ -0,0 +1,107 @@
+// Credit to (adopted from): https://github.com/sindresorhus/slugify/
+
+export interface SlugifyOptions {
+  /**
+   * Default: `-`
+   */
+  separator?: string
+  /**
+   * Default: true
+   */
+  lowercase?: boolean
+  /**
+   * Default: true
+   */
+  decamelize?: boolean
+  /**
+   * Default: []
+   */
+  preserveCharacters?: string[]
+}
+
+export function _slugify(s: string, opt: SlugifyOptions = {}): string {
+  opt = {
+    separator: '-',
+    lowercase: true,
+    decamelize: true,
+    preserveCharacters: [],
+    ...opt,
+  }
+
+  if (opt.decamelize) {
+    s = decamelize(s)
+  }
+
+  const patternSlug = buildPatternSlug(opt)
+
+  if (opt.lowercase) {
+    s = s.toLowerCase()
+  }
+
+  // based on https://stackoverflow.com/a/23633850/4919972
+  // Combining Diacritical Marks
+  // https://www.unicode.org/charts/PDF/U0300.pdf
+  // biome-ignore lint/suspicious/noMisleadingCharacterClass: ok
+  s = s.normalize('NFKD').replaceAll(/[\u0300-\u036F]/g, '')
+
+  // Detect contractions/possessives by looking for any word followed by a `'t`
+  // or `'s` in isolation and then remove it.
+  s = s.replaceAll(/([a-zA-Z\d]+)'([ts])(\s|$)/g, '$1$2$3')
+
+  s = s.replace(patternSlug, opt.separator!)
+  s = s.replaceAll('\\', '')
+
+  if (opt.separator) {
+    s = removeMootSeparators(s, opt.separator)
+  }
+
+  return s
+}
+
+function buildPatternSlug(options: any): RegExp {
+  let negationSetPattern = String.raw`a-z\d`
+  negationSetPattern += options.lowercase ? '' : 'A-Z'
+
+  if (options.preserveCharacters.length > 0) {
+    for (const character of options.preserveCharacters) {
+      if (character === options.separator) {
+        throw new Error(
+          `The separator character \`${options.separator}\` cannot be included in preserved characters: ${options.preserveCharacters}`,
+        )
+      }
+
+      negationSetPattern += escapeStringRegexp(character)
+    }
+  }
+
+  return new RegExp(`[^${negationSetPattern}]+`, 'g')
+}
+
+function removeMootSeparators(s: string, separator: string): string {
+  const escapedSeparator = escapeStringRegexp(separator)
+
+  return s
+    .replaceAll(new RegExp(`${escapedSeparator}{2,}`, 'g'), separator)
+    .replaceAll(new RegExp(`^${escapedSeparator}|${escapedSeparator}$`, 'g'), '')
+}
+
+function decamelize(s: string): string {
+  return (
+    s
+      // Separate capitalized words.
+      .replaceAll(/([A-Z]{2,})(\d+)/g, '$1 $2')
+      .replaceAll(/([a-z\d]+)([A-Z]{2,})/g, '$1 $2')
+
+      .replaceAll(/([a-z\d])([A-Z])/g, '$1 $2')
+      // `[a-rt-z]` matches all lowercase characters except `s`.
+      // This avoids matching plural acronyms like `APIs`.
+      .replaceAll(/([A-Z]+)([A-Z][a-rt-z\d]+)/g, '$1 $2')
+  )
+}
+
+// based on: https://github.com/sindresorhus/escape-string-regexp/
+function escapeStringRegexp(s: string): string {
+  // Escape characters with special meaning either inside or outside character sets.
+  // Use a simple backslash escape when it’s always valid, and a `\xnn` escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.
+  return s.replaceAll(/[|\\{}()[\]^$+*?.]/g, String.raw`\$&`).replaceAll('-', String.raw`\x2d`)
+}