@tstdl/base 0.93.28 → 0.93.29

package/orm/sqls.js

@@ -10,6 +10,10 @@ import { sql, Table } from 'drizzle-orm';
 export const TRANSACTION_TIMESTAMP = sql `transaction_timestamp()`;
 /** Drizzle SQL helper for generating a random UUID (v4). Returns a Uuid string. */
 export const RANDOM_UUID_V4 = sql `gen_random_uuid()`;
+export function array(values) {
+    const valueString = sql.join(values, sql.raw(', '));
+    return sql `ARRAY[${valueString}]`;
+}
 export function autoAlias(column) {
     return sql `${column}`.as(`${column.table[Table['Symbol']['Name']]}_${column.name}`);
 }
@@ -98,11 +102,8 @@ export function greatest(...values) {
 export function unnest(array) {
     return sql `unnest(${array})`;
 }
-function getLanguageSql(language) {
-    return isString(language) ? sql `'${sql.raw(language)}'` : sql `${language}`;
-}
 export function toTsVector(language, text) {
-    return sql `to_tsvector(${getLanguageSql(language)}, ${text})`;
+    return sql `to_tsvector(${language}, ${text})`;
 }
 export function tsvectorToArray(tsvector) {
     return sql `tsvector_to_array(${tsvector})`;
@@ -115,7 +116,7 @@ export function tsvectorToArray(tsvector) {
  * @returns A Drizzle SQL object representing the tsquery.
  */
 export function toTsQuery(language, text) {
-    return sql `to_tsquery(${getLanguageSql(language)}, ${text})`;
+    return sql `to_tsquery(${language}, ${text})`;
 }
 /**
  * Creates a PostgreSQL `plainto_tsquery` function call.
@@ -126,7 +127,7 @@ export function toTsQuery(language, text) {
  * @returns A Drizzle SQL object representing the tsquery.
  */
 export function plainToTsQuery(language, text) {
-    return sql `plainto_tsquery(${getLanguageSql(language)}, ${text})`;
+    return sql `plainto_tsquery(${language}, ${text})`;
 }
 /**
  * Creates a PostgreSQL `phraseto_tsquery` function call.
@@ -136,7 +137,7 @@ export function plainToTsQuery(language, text) {
  * @returns A Drizzle SQL object representing the tsquery.
  */
 export function phraseToTsQuery(language, text) {
-    return sql `phraseto_tsquery(${getLanguageSql(language)}, ${text})`;
+    return sql `phraseto_tsquery(${language}, ${text})`;
 }
 /**
  * Creates a PostgreSQL `websearch_to_tsquery` function call.
@@ -147,7 +148,7 @@ export function phraseToTsQuery(language, text) {
  * @returns A Drizzle SQL object representing the tsquery.
  */
 export function websearchToTsQuery(language, text) {
-    return sql `websearch_to_tsquery(${getLanguageSql(language)}, ${text})`;
+    return sql `websearch_to_tsquery(${language}, ${text})`;
 }
 /**
  * Creates a PostgreSQL `setweight` function call.
@@ -170,7 +171,7 @@ export function tsRankCd(tsvector, tsquery, options) {
     const parameters = [];
     if (isDefined(options?.weights)) {
         const weightParts = options.weights.map((w) => sql.raw(String(w)));
-        parameters.push(sql `ARRAY[${sql.join(weightParts, sql.raw(', '))}]::real[]`);
+        parameters.push(sql `${array(weightParts)}::real[]`);
     }
     parameters.push(tsvector, tsquery);
     if (isDefined(options?.normalization)) {
@@ -195,9 +196,9 @@ export function tsHeadline(language, document, tsquery, options) {
     const documentSql = isString(document) ? sql `${document}` : document;
     if (isDefined(options)) {
         const optionsString = Object.entries(options).map(([key, value]) => `${key[0].toUpperCase()}${key.slice(1)}=${String(value)}`).join(', ');
-        return sql `ts_headline(${getLanguageSql(language)}, ${documentSql}, ${tsquery}, '${sql.raw(optionsString)}')`;
+        return sql `ts_headline(${language}, ${documentSql}, ${tsquery}, '${sql.raw(optionsString)}')`;
     }
-    return sql `ts_headline(${getLanguageSql(language)}, ${documentSql}, ${tsquery})`;
+    return sql `ts_headline(${language}, ${documentSql}, ${tsquery})`;
 }
 /**
  * Creates a PostgreSQL `similarity` function call (from pg_trgm extension).
@@ -207,9 +208,7 @@ export function tsHeadline(language, document, tsquery, options) {
  * @returns A Drizzle SQL object representing the similarity score (0 to 1).
  */
 export function similarity(left, right) {
-    const leftSql = isString(left) ? sql `${left}` : left;
-    const rightSql = isString(right) ? sql `${right}` : right;
-    return sql `similarity(${leftSql}, ${rightSql})`;
+    return sql `similarity(${left}, ${right})`;
 }
 /**
  * Creates a PostgreSQL `word_similarity` function call (from pg_trgm extension).
@@ -219,9 +218,7 @@ export function similarity(left, right) {
  * @returns A Drizzle SQL object representing the similarity score (0 to 1).
  */
 export function wordSimilarity(left, right) {
-    const leftSql = isString(left) ? sql `${left}` : left;
-    const rightSql = isString(right) ? sql `${right}` : right;
-    return sql `word_similarity(${leftSql}, ${rightSql})`;
+    return sql `word_similarity(${left}, ${right})`;
 }
 /**
  * Creates a PostgreSQL `strict_word_similarity` function call (from pg_trgm extension).
@@ -231,37 +228,30 @@ export function wordSimilarity(left, right) {
  * @returns A Drizzle SQL object representing the similarity score (0 to 1).
  */
 export function strictWordSimilarity(left, right) {
-    const leftSql = isString(left) ? sql `${left}` : left;
-    const rightSql = isString(right) ? sql `${right}` : right;
-    return sql `strict_word_similarity(${leftSql}, ${rightSql})`;
+    return sql `strict_word_similarity(${left}, ${right})`;
 }
 export function isSimilar(left, right) {
-    const leftSql = isString(left) ? sql `${left}` : left;
-    const rightSql = isString(right) ? sql `${right}` : right;
-    return sql `(${leftSql} % ${rightSql})`;
+    return sql `(${left} % ${right})`;
 }
 export function isWordSimilar(left, right) {
-    const leftSql = isString(left) ? sql `${left}` : left;
-    const rightSql = isString(right) ? sql `${right}` : right;
-    return sql `(${leftSql} <% ${rightSql})`;
+    return sql `(${left} <% ${right})`;
 }
 export function isStrictWordSimilar(left, right) {
-    const leftSql = isString(left) ? sql `${left}` : left;
-    const rightSql = isString(right) ? sql `${right}` : right;
-    return sql `(${leftSql} <<% ${rightSql})`;
+    return sql `(${left} <<% ${right})`;
 }
 export function distance(left, right) {
-    const leftSql = isString(left) ? sql `${left}` : left;
-    const rightSql = isString(right) ? sql `${right}` : right;
-    return sql `(${leftSql} <-> ${rightSql})`;
+    return sql `(${left} <-> ${right})`;
 }
 export function wordDistance(left, right) {
-    const leftSql = isString(left) ? sql `${left}` : left;
-    const rightSql = isString(right) ? sql `${right}` : right;
-    return sql `(${leftSql} <<-> ${rightSql})`;
+    return sql `(${left} <<-> ${right})`;
 }
 export function strictWordDistance(left, right) {
-    const leftSql = isString(left) ? sql `${left}` : left;
-    const rightSql = isString(right) ? sql `${right}` : right;
-    return sql `(${leftSql} <<<-> ${rightSql})`;
+    return sql `(${left} <<<-> ${right})`;
+}
+export function jsonbBuildObject(properties) {
+    const entries = Array.isArray(properties) ? properties : Object.entries(properties);
+    const chunks = entries
+        .filter(([_, propValue]) => isDefined(propValue))
+        .map(([propKey, propValue]) => sql `'${sql.raw(propKey)}', ${propValue}`);
+    return sql `jsonb_build_object(${sql.join(chunks, sql `, `)})`;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.28",
+  "version": "0.93.29",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -19,7 +19,7 @@
     "tsc:watch": "tsc --watch",
     "tsc-alias:watch": "tsc-alias --watch",
     "cleanup:dist": "rm -vrf dist/tools/",
-    "generate:migration": "./scripts/manage-orm.sh generate",
+    "generate:migration": "./scripts/manage-orm.sh generate && npm run copy:orm",
     "generate:readmes": "deno run --allow-run=code2prompt --allow-read --allow-write=source --allow-net=generativelanguage.googleapis.com --allow-env=GEMINI_API_KEY generate-readmes.ts",
     "generate:readmes:new-only": "npm run generate:readmes -- --skip-existing",
     "generate:llms.md": "npm run build:dts && npm run cleanup:dist && ./scripts/generate-llms-docs.sh",
@@ -132,11 +132,11 @@
     "reflect-metadata": "^0.2",
     "rxjs": "^7.8",
     "ts-pattern": "^5.9",
-    "type-fest": "^5.1"
+    "type-fest": "^5.2"
   },
   "peerDependencies": {
     "@google-cloud/storage": "^7.17",
-    "@google/genai": "^1.28",
+    "@google/genai": "^1.29",
     "@tstdl/angular": "^0.93",
     "@zxcvbn-ts/core": "^3.0",
     "@zxcvbn-ts/language-common": "^3.0",
@@ -171,8 +171,8 @@
     "@types/pg": "8.15",
     "concurrently": "9.2",
     "drizzle-kit": "0.31",
-    "eslint": "9.38",
-    "globals": "16.4",
+    "eslint": "9.39",
+    "globals": "16.5",
     "tsc-alias": "1.8",
     "typedoc-github-wiki-theme": "2.1",
     "typedoc-plugin-markdown": "4.9",

package/test/drizzle/0000_natural_cannonball.sql

@@ -0,0 +1,9 @@
+CREATE TABLE "test"."test" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"title" text NOT NULL,
+	"content" text NOT NULL,
+	"tags" text NOT NULL,
+	"language" text NOT NULL
+);
+--> statement-breakpoint
+CREATE INDEX "test_parade_idx" ON "test"."test" USING bm25 ("id","language","title","content","tags",(("title" || ' ' || "content" || ' ' || "tags")::pdb.simple('alias=search_text')),(('foo')::pdb.simple('alias=foo'))) WITH (key_field='id',mutable_segment_rows=12);

package/test/drizzle/meta/0000_snapshot.json

@@ -1,5 +1,5 @@
 {
-  "id": "cfbaaee3-4960-412e-83b7-0f58ea61969d",
+  "id": "bbffc0f2-678b-42e9-8121-1731a04b8987",
   "prevId": "00000000-0000-0000-0000-000000000000",
   "version": "7",
   "dialect": "postgresql",
@@ -41,8 +41,8 @@
         }
       },
       "indexes": {
-        "test_id_title_content_tags_idx": {
-          "name": "test_id_title_content_tags_idx",
+        "test_parade_idx": {
+          "name": "test_parade_idx",
           "columns": [
             {
               "expression": "id",
@@ -51,21 +51,39 @@
               "nulls": "last"
             },
             {
-              "expression": "title",
-              "isExpression": false,
+              "expression": "\"language\"",
               "asc": true,
+              "isExpression": true,
               "nulls": "last"
             },
             {
-              "expression": "content",
-              "isExpression": false,
+              "expression": "\"title\"",
               "asc": true,
+              "isExpression": true,
               "nulls": "last"
             },
             {
-              "expression": "tags",
-              "isExpression": false,
+              "expression": "\"content\"",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "\"tags\"",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "((\"title\" || ' ' || \"content\" || ' ' || \"tags\")::pdb.simple('alias=search_text'))",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "(('foo')::pdb.simple('alias=foo'))",
               "asc": true,
+              "isExpression": true,
               "nulls": "last"
             }
           ],
@@ -73,7 +91,8 @@
           "concurrently": false,
           "method": "bm25",
           "with": {
-            "key_field": "'id'"
+            "key_field": "'id'",
+            "mutable_segment_rows": 12
           }
         }
       },

package/test/drizzle/meta/_journal.json

@@ -5,8 +5,8 @@
     {
       "idx": 0,
       "version": "7",
-      "when": 1761929933695,
-      "tag": "0000_sturdy_patch",
+      "when": 1762381204799,
+      "tag": "0000_natural_cannonball",
       "breakpoints": true
     }
   ]

package/test/test.model.js

@@ -7,7 +7,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { BaseEntity, Index } from '../orm/index.js';
+import { sql } from 'drizzle-orm';
+import { BaseEntity, ParadeCompoundIndex, ParadeExpressionIndex, ParadeIndex } from '../orm/index.js';
 import { StringProperty } from '../schema/index.js';
 let Test = class Test extends BaseEntity {
     title;
@@ -16,14 +17,17 @@ let Test = class Test extends BaseEntity {
     language;
 };
 __decorate([
+    ParadeIndex(),
     StringProperty(),
     __metadata("design:type", String)
 ], Test.prototype, "title", void 0);
 __decorate([
+    ParadeIndex(),
     StringProperty(),
     __metadata("design:type", String)
 ], Test.prototype, "content", void 0);
 __decorate([
+    ParadeIndex(),
     StringProperty(),
     __metadata("design:type", String)
 ], Test.prototype, "tags", void 0);
@@ -32,7 +36,9 @@ __decorate([
     __metadata("design:type", String)
 ], Test.prototype, "language", void 0);
 Test = __decorate([
-    Index(['id', 'title', 'content', 'tags'], { using: 'bm25', with: { key_field: `'id'` } })
+    ParadeExpressionIndex('foo', () => sql `'foo'`),
+    ParadeCompoundIndex('search_text', (table) => [table.title, 'content', 'tags']),
+    ParadeIndex({ columns: ['language'], mutableSegmentRows: 12 })
 ], Test);
 export { Test };
 export const testData = [

package/test1.js

@@ -53,18 +53,18 @@ async function main(_cancellationSignal) {
     if (await repository.count() == 0) {
         await repository.insertMany(testData);
     }
-    const result = await repository.search({
+    const result = await repository.loadManyByQuery({
+        title: { $parade: { match: { value: 'quick fox', distance: 2 } } },
+    });
+    const result2 = await repository.search({
         query: {
-            $trigram: {
-                fields: ['title'],
-                query: 'lorem ipsum dolor sit amet',
-            },
+            $parade: { fields: ['content'], query: 'vibrant city' },
         },
-        distinct: ['title'],
-        order: (x) => ['title', x.score],
-        limit: 10,
+        highlight: { source: 'content', includePositions: true },
     });
-    console.log(result);
+    for (const item of result2) {
+        console.log(item);
+    }
 }
 Application.run('Test', [
     provideInitializer(bootstrap),

package/utils/enum.js

@@ -10,7 +10,7 @@ const memoizedEnumValues = memoizeSingle((enumeration) => {
     const entries = enumEntries(enumeration);
     return entries.map((entry) => entry[1]);
 }, { weak: true });
-const memoizedReversedEnum = memoizeSingle((enumeration) => mapObject(enumeration, (value, key) => [value, key]), { weak: true });
+const memoizedReversedEnum = memoizeSingle((enumeration) => mapObject(enumeration, (key, value) => [value, key]), { weak: true });
 export function enumValueName(enumeration, value) {
     return reversedEnum(enumeration)[value];
 }

package/utils/object/object.d.ts

@@ -1,3 +1,4 @@
+import type { SnakeCasedProperties } from 'type-fest';
 import { type JsonPathInput } from '../../json-path/json-path.js';
 import type { BaseType, Entries, FromEntries, ObjectLiteral, Optionalize, OptionalizeNull, PickBy, Record, SimplifyObject, UnionToIntersection } from '../../types/index.js';
 export declare function hasOwnProperty<T extends ObjectLiteral, K extends keyof UnionToIntersection<T>>(obj: T, key: K): obj is Extract<T, Partial<Record<K>>>;
@@ -13,15 +14,16 @@ export declare function objectKeys<T extends ObjectLiteral>(object: T): (keyof T
 export declare function objectValues<T extends ObjectLiteral>(object: T): (T[keyof T])[];
 export declare function fromEntries<A>(entries: A): FromEntries<A>;
 export declare function fromEntries<K extends PropertyKey, T>(entries: Iterable<readonly [K, T]>): Record<K, T>;
-export declare function mapObject<T extends ObjectLiteral, K extends PropertyKey, V>(object: T, mapper: (value: T[keyof T], key: keyof T) => [key: K, value: V]): Record<K, V>;
-export declare function mapObjectAsync<T extends ObjectLiteral, K extends PropertyKey, V>(object: T, mapper: (value: T[keyof T], key: keyof T) => Promise<[key: K, value: V]>): Promise<Record<K, V>>;
+export declare function mapObject<T extends ObjectLiteral, K extends PropertyKey, V>(object: T, mapper: (key: keyof T, value: T[keyof T]) => [key: K, value: V] | null | undefined): Record<K, V>;
+export declare function mapObjectAsync<T extends ObjectLiteral, K extends PropertyKey, V>(object: T, mapper: (key: keyof T, value: T[keyof T]) => Promise<[key: K, value: V] | null | undefined>): Promise<Record<K, V>>;
 export declare function mapObjectValues<T extends ObjectLiteral, V>(object: T, mapper: (value: T[keyof T], key: keyof T) => V): Record<keyof T, V>;
 export declare function mapObjectKeys<T extends ObjectLiteral, K extends PropertyKey>(object: T, mapper: (key: keyof T, value: T[keyof T]) => K): Record<K, T[keyof T]>;
+export declare function mapObjectKeysToSnakeCase<T extends Record<string>>(object: T): SnakeCasedProperties<T>;
 export declare function mapObjectValuesAsync<T extends ObjectLiteral, V>(object: T, mapper: (value: T[keyof T], key: keyof T) => Promise<V>): Promise<Record<keyof T, V>>;
 export declare function filterObject<T extends ObjectLiteral, U extends T[keyof T]>(object: T, predicate: (value: T[keyof T], key: keyof T) => value is U): PickBy<T, U>;
 export declare function filterObject<T extends ObjectLiteral>(object: T, predicate: (value: T[keyof T], key: keyof T) => boolean): Partial<T>;
 export declare function filterObjectAsync<T extends ObjectLiteral>(object: T, predicate: (value: T[keyof T], key: keyof T) => Promise<boolean>): Promise<Partial<T>>;
-export declare function filterUndefinedFromRecord<K extends PropertyKey, V>(record: Record<K, V>): Record<BaseType<K>, Exclude<V, undefined>>;
+export declare function filterUndefinedFromRecord<K extends PropertyKey, V>(record: Partial<Record<K, V>>): Record<BaseType<K>, Exclude<V, undefined>>;
 export declare function filterNullishFromRecord<K extends PropertyKey, V>(record: Record<K, V>): Record<BaseType<K>, Exclude<V, null | undefined>>;
 export declare function filterUndefinedObjectProperties<T extends ObjectLiteral>(object: T): SimplifyObject<Optionalize<T>>;
 export declare function filterNullishObjectProperties<T extends ObjectLiteral>(object: T): SimplifyObject<OptionalizeNull<Optionalize<T>>>;

package/utils/object/object.js

@@ -2,7 +2,8 @@ import { JsonPath } from '../../json-path/json-path.js';
 import { filterAsync } from '../async-iterable-helpers/filter.js';
 import { mapAsync } from '../async-iterable-helpers/map.js';
 import { toArrayAsync } from '../async-iterable-helpers/to-array.js';
-import { isArray, isDefined, isNotNullOrUndefined, isObject, isSymbol, isUndefined } from '../type-guards.js';
+import { toSnakeCase } from '../string/index.js';
+import { isArray, isDefined, isNotNullOrUndefined, isNullOrUndefined, isObject, isSymbol, isUndefined } from '../type-guards.js';
 export function hasOwnProperty(obj, key) {
     return Object.hasOwn(obj, key);
 }
@@ -26,22 +27,31 @@ export function fromEntries(entries) {
     return Object.fromEntries(entries);
 }
 export function mapObject(object, mapper) {
-    const mappedEntries = objectKeys(object).map((key) => mapper(object[key], key));
+    const mappedEntries = objectKeys(object).flatMap((key) => {
+        const result = mapper(key, object[key]);
+        if (isNullOrUndefined(result)) {
+            return [];
+        }
+        return [result];
+    });
     return Object.fromEntries(mappedEntries);
 }
 export async function mapObjectAsync(object, mapper) {
     const entries = objectKeys(object);
-    const mappedEntries = await toArrayAsync(mapAsync(entries, async (key) => await mapper(object[key], key)));
-    return Object.fromEntries(mappedEntries);
+    const mappedEntries = await toArrayAsync(mapAsync(entries, async (key) => await mapper(key, object[key])));
+    return Object.fromEntries(mappedEntries.filter(isNotNullOrUndefined));
 }
 export function mapObjectValues(object, mapper) {
-    return mapObject(object, (value, key) => [key, mapper(value, key)]);
+    return mapObject(object, (key, value) => [key, mapper(value, key)]);
 }
 export function mapObjectKeys(object, mapper) {
-    return mapObject(object, (value, key) => [mapper(key, value), value]);
+    return mapObject(object, (key, value) => [mapper(key, value), value]);
+}
+export function mapObjectKeysToSnakeCase(object) {
+    return mapObjectKeys(object, (key) => toSnakeCase(key));
 }
 export async function mapObjectValuesAsync(object, mapper) {
-    return await mapObjectAsync(object, async (value, key) => [key, await mapper(value, key)]);
+    return await mapObjectAsync(object, async (key, value) => [key, await mapper(value, key)]);
 }
 export function filterObject(object, predicate) {
     const mappedEntries = objectEntries(object).filter(([key, value]) => predicate(value, key));

package/utils/string/casing.d.ts

@@ -0,0 +1,3 @@
+import type { CamelCase, SnakeCase } from 'type-fest';
+export declare function toSnakeCase<T extends string>(value: T): SnakeCase<T>;
+export declare function toCamelCase<T extends string>(value: T): CamelCase<T>;

package/utils/string/casing.js

@@ -0,0 +1,15 @@
+const wordsPattern = /[\da-z]+|[A-Z]+(?![a-z])|[A-Z][\da-z]+/g;
+export function toSnakeCase(value) {
+    const words = matchWords(value);
+    return words.map((word) => word.toLowerCase()).join('_');
+}
+export function toCamelCase(value) {
+    const words = matchWords(value);
+    return words.reduce((acc, word, index) => {
+        const formattedWord = (index == 0) ? word.toLowerCase() : `${word[0].toUpperCase()}${word.slice(1)}`;
+        return acc + formattedWord;
+    }, '');
+}
+function matchWords(value) {
+    return value.replace(/['\u2019]/g, '').match(wordsPattern) ?? [];
+}

package/utils/string/index.d.ts

@@ -1,5 +1,5 @@
+export * from './casing.js';
 export * from './hypenate.js';
 export * from './normalize.js';
-export * from './snake-case.js';
 export * from './title-case.js';
 export * from './trim.js';

package/utils/string/index.js

@@ -1,5 +1,5 @@
+export * from './casing.js';
 export * from './hypenate.js';
 export * from './normalize.js';
-export * from './snake-case.js';
 export * from './title-case.js';
 export * from './trim.js';

package/test/drizzle/0000_sturdy_patch.sql

@@ -1,9 +0,0 @@
-CREATE TABLE "test"."test" (
-	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
-	"title" text NOT NULL,
-	"content" text NOT NULL,
-	"tags" text NOT NULL,
-	"language" text NOT NULL
-);
---> statement-breakpoint
-CREATE INDEX "test_id_title_content_tags_idx" ON "test"."test" USING bm25 ("id","title","content","tags") WITH (key_field='id');

package/utils/string/snake-case.d.ts

@@ -1 +0,0 @@
-export declare function toSnakeCase(value: string): string;

package/utils/string/snake-case.js

@@ -1,4 +0,0 @@
-const pattern = /(?=[A-Z])/u;
-export function toSnakeCase(value) {
-    return value.split(pattern).join('_').toLowerCase();
-}