@rvoh/dream 0.29.1

package/dist/esm/src/helpers/db/runMigration.js

@@ -0,0 +1,94 @@
+import * as fs from 'fs/promises';
+import { FileMigrationProvider, Migrator } from 'kysely';
+import * as path from 'path';
+import DreamDbConnection from '../../db/DreamDbConnection.js';
+import db from '../../db/index.js';
+import DreamApplication from '../../dream-application/index.js';
+export default async function runMigration({ mode = 'migrate' } = {}) {
+    const dreamApp = DreamApplication.getOrFail();
+    const migrationFolder = path.join(dreamApp.projectRoot, dreamApp.paths.db, 'migrations');
+    const kyselyDb = db('primary');
+    const migrator = new Migrator({
+        db: kyselyDb,
+        allowUnorderedMigrations: true,
+        provider: new FileMigrationProvider({
+            fs,
+            path,
+            migrationFolder,
+        }),
+    });
+    if (mode === 'migrate') {
+        await migrate(migrator, migrationFolder);
+    }
+    else if (mode === 'rollback') {
+        await rollback(migrator);
+    }
+    await DreamDbConnection.dropAllConnections();
+}
+async function migrate(migrator, migrationFolder) {
+    let nextMigrationRequiringNewTransaction = await findNextMigrationRequiringNewTransaction(migrator, migrationFolder);
+    while (nextMigrationRequiringNewTransaction) {
+        const migrateTo = await findMigrationBeforeNextMigrationRequiringNewTransaction(migrator, nextMigrationRequiringNewTransaction);
+        if (migrateTo) {
+            const { error, results } = await migrator.migrateTo(migrateTo);
+            logResults(results, 'migrate');
+            if (error) {
+                await handleError(error, 'migrate');
+                break;
+            }
+        }
+        nextMigrationRequiringNewTransaction = await findNextMigrationRequiringNewTransaction(migrator, migrationFolder, { ignore: nextMigrationRequiringNewTransaction });
+    }
+    const { error, results } = await migrator.migrateToLatest();
+    logResults(results, 'migrate');
+    if (error)
+        await handleError(error, 'migrate');
+}
+async function findMigrationBeforeNextMigrationRequiringNewTransaction(migrator, nextMigrationRequiringNewTransaction) {
+    const notYetRunMigrations = (await migrator.getMigrations())
+        .filter(migrationInfo => !migrationInfo.executedAt)
+        .map(migrationInfo => migrationInfo.name);
+    const indexOfNextMigrationRequiringNewTransaction = notYetRunMigrations.findIndex(migrationName => migrationName === nextMigrationRequiringNewTransaction);
+    return notYetRunMigrations[indexOfNextMigrationRequiringNewTransaction - 1];
+}
+async function findNextMigrationRequiringNewTransaction(migrator, migrationFolder, { ignore } = {}) {
+    const notYetRunMigrations = (await migrator.getMigrations())
+        .filter(migrationInfo => !migrationInfo.executedAt)
+        .map(migrationInfo => migrationInfo.name)
+        .filter(name => name !== ignore);
+    for (const notYetRunMigration of notYetRunMigrations) {
+        const filepath = path.join(migrationFolder, `${notYetRunMigration}.ts`);
+        const migrationRequiresNewTransaction = (await fs.readFile(filepath)).includes('DreamMigrationHelpers.dropEnumValue');
+        if (migrationRequiresNewTransaction)
+            return notYetRunMigration;
+    }
+}
+async function rollback(migrator) {
+    const { error, results } = await migrator.migrateDown();
+    logResults(results, 'rollback');
+    if (error)
+        await handleError(error, 'rollback');
+}
+async function handleError(error, mode) {
+    await DreamDbConnection.dropAllConnections();
+    DreamApplication.logWithLevel('error', `failed to ${migratedActionCurrentTense(mode)}`);
+    DreamApplication.logWithLevel('error', error);
+    process.exit(1);
+}
+function migratedActionCurrentTense(mode) {
+    return mode === 'migrate' ? 'migrate' : 'roll';
+}
+function migratedActionPastTense(mode) {
+    return mode === 'migrate' ? 'migrated' : 'rolled back';
+}
+function logResults(results, mode) {
+    results?.forEach(it => {
+        if (it.status === 'Success') {
+            console.log(`migration "${it.migrationName}" was ${migratedActionPastTense(mode)} successfully`);
+        }
+        else if (it.status === 'Error') {
+            console.log(it);
+            console.error(`failed to ${migratedActionCurrentTense(mode)} migration "${it.migrationName}"`);
+        }
+    });
+}

package/dist/esm/src/helpers/db/truncateDb.js

@@ -0,0 +1,24 @@
+import EnvInternal from '../EnvInternal.js';
+import loadPgClient from './loadPgClient.js';
+export default async function truncate() {
+    // this was only ever written to clear the db between tests,
+    // so there is no way to truncate in dev/prod
+    if (!EnvInternal.isTest)
+        return false;
+    const client = await loadPgClient();
+    await client.query(`
+DO $$
+DECLARE row RECORD;
+BEGIN
+FOR row IN SELECT table_name
+  FROM information_schema.tables
+  WHERE table_type='BASE TABLE'
+  AND table_schema='public'
+  AND table_name NOT IN ('migrations')
+LOOP
+  EXECUTE format('TRUNCATE TABLE %I CONTINUE IDENTITY RESTRICT;',row.table_name);
+END LOOP;
+END;
+$$;
+`);
+}

package/dist/esm/src/helpers/db/types/isDatabaseArrayColumn.js

@@ -0,0 +1,3 @@
+export default function isDatabaseArrayColumn(dreamClass, column) {
+    return /\[\]$/.test(dreamClass['cachedTypeFor'](column));
+}

package/dist/esm/src/helpers/db/types/isDateColumn.js

@@ -0,0 +1,3 @@
+export default function isDateColumn(dreamClass, column) {
+    return dreamClass['cachedTypeFor'](column) === 'date';
+}

package/dist/esm/src/helpers/db/types/isDateTimeColumn.js

@@ -0,0 +1,3 @@
+export default function isDateTimeColumn(dreamClass, column) {
+    return !!dreamClass['cachedTypeFor'](column)?.includes('timestamp');
+}

package/dist/esm/src/helpers/db/types/isJsonColumn.js

@@ -0,0 +1,3 @@
+export default function isJsonColumn(dreamClass, column) {
+    return ['json', 'jsonb'].includes(dreamClass['cachedTypeFor'](column));
+}

package/dist/esm/src/helpers/debug.js

@@ -0,0 +1,8 @@
+import EnvInternal from './EnvInternal.js';
+export default function debug(message, { level = 'log', } = {}) {
+    if (EnvInternal.isTest)
+        return;
+    if (!EnvInternal.isDebug)
+        return;
+    console[level](message);
+}

package/dist/esm/src/helpers/dreamOrPsychicCoreDevelopment.js

@@ -0,0 +1,7 @@
+// normally we wouldn't consider psychic core development,
+// but given the awkward nature of the test-app folder,
+import EnvInternal from './EnvInternal.js';
+// it is sometimes necessary to consider it
+export default function dreamOrPsychicCoreDevelopment() {
+    return EnvInternal.boolean('DREAM_CORE_DEVELOPMENT') || EnvInternal.boolean('PSYCHIC_CORE_DEVELOPMENT');
+}

package/dist/esm/src/helpers/filterObjectByKey.js

@@ -0,0 +1,11 @@
+import protectAgainstPollutingAssignment from './protectAgainstPollutingAssignment.js';
+export default function filterObjectByKey(obj, arr) {
+    const workingObj = {};
+    const booleanObj = {};
+    arr.forEach(key => (booleanObj[key] = true));
+    arr.forEach(key => {
+        if (booleanObj[key])
+            workingObj[protectAgainstPollutingAssignment(key)] = obj[key];
+    });
+    return workingObj;
+}

package/dist/esm/src/helpers/getFiles.js

@@ -0,0 +1,17 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+export default async function getFiles(dir) {
+    try {
+        const dirents = await fs.readdir(dir, { withFileTypes: true });
+        const files = await Promise.all(dirents.map(dirent => {
+            const res = path.resolve(dir, dirent.name);
+            return dirent.isDirectory() ? getFiles(res) : res.replace(/\.ts$/, '.js');
+        }));
+        return Array.prototype.concat(...files);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return [];
+        throw err;
+    }
+}

package/dist/esm/src/helpers/globalClassNameFromFullyQualifiedModelName.js

@@ -0,0 +1,4 @@
+import standardizeFullyQualifiedModelName from './standardizeFullyQualifiedModelName.js';
+export default function (str) {
+    return standardizeFullyQualifiedModelName(str).replace(/\//g, '');
+}

package/dist/esm/src/helpers/hyphenize.js

@@ -0,0 +1,8 @@
+import stringCase from './stringCasing.js';
+import { snakeifyString } from './snakeify.js';
+export default function hyphenize(target) {
+    return stringCase(target, hyphenizeString);
+}
+function hyphenizeString(str) {
+    return snakeifyString(str).replace(/_/g, '-');
+}

package/dist/esm/src/helpers/inferSerializerFromDreamOrViewModel.js

@@ -0,0 +1,12 @@
+import DreamApplication from '../dream-application/index.js';
+export default function inferSerializerFromDreamOrViewModel(obj, serializerKey = undefined) {
+    const globalName = obj?.['serializers']?.[serializerKey || 'default'] || null;
+    if (globalName) {
+        const dreamApp = DreamApplication.getOrFail();
+        return dreamApp.serializers[globalName] || null;
+    }
+    return null;
+}
+export function inferSerializerFromDreamClassOrViewModelClass(classDef, serializerKey = undefined) {
+    return inferSerializerFromDreamOrViewModel(classDef.prototype, serializerKey);
+}

package/dist/esm/src/helpers/isEmpty.js

@@ -0,0 +1,5 @@
+export default function isEmpty(value) {
+    if (Array.isArray(value))
+        return value.length === 0;
+    return Object.keys(value).length === 0;
+}

package/dist/esm/src/helpers/loadEnv.js

@@ -0,0 +1,35 @@
+import * as dotenv from 'dotenv';
+import EnvInternal from './EnvInternal.js';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+let finalDirname;
+if (typeof importMeta !== 'undefined') {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    const __filename = fileURLToPath(import.meta.url);
+    finalDirname = dirname(__filename);
+}
+else {
+    try {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        finalDirname = __dirname;
+    }
+    catch {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        const __filename = fileURLToPath(import.meta.url);
+        finalDirname = dirname(__filename);
+    }
+}
+const fileName = `.env${EnvInternal.isTest ? '.test' : ''}`;
+let dotenvpath = '';
+if (EnvInternal.boolean('DREAM_CORE_DEVELOPMENT')) {
+    dotenvpath = EnvInternal.boolean('DREAM_CORE_SPEC_RUN')
+        ? finalDirname + `/../../${fileName}`
+        : finalDirname + `/../../../${fileName}`;
+}
+else {
+    dotenvpath = `../../${fileName}`;
+}
+dotenv.config({ path: dotenvpath });

package/dist/esm/src/helpers/loadRepl.js

@@ -0,0 +1,22 @@
+import './loadEnv.js';
+import { DateTime } from 'luxon';
+import DreamApplication from '../dream-application/index.js';
+import Encrypt from '../encrypt/index.js';
+import ops from '../ops/index.js';
+import CalendarDate from './CalendarDate.js';
+import pascalizePath from './pascalizePath.js';
+export default function loadRepl(context) {
+    const dreamApp = DreamApplication.getOrFail();
+    context.DateTime = DateTime;
+    context.CalendarDate = CalendarDate;
+    context.Encrypt = Encrypt;
+    context.ops = ops;
+    for (const globalName of Object.keys(dreamApp.models)) {
+        context[pascalizePath(globalName)] = dreamApp.models[globalName];
+    }
+    for (const globalName of Object.keys(dreamApp.services)) {
+        if (!context[globalName]) {
+            context[pascalizePath(globalName)] = dreamApp.services[globalName];
+        }
+    }
+}

package/dist/esm/src/helpers/migrationVersion.js

@@ -0,0 +1,3 @@
+export default function migrationVersion() {
+    return new Date().getTime();
+}

package/dist/esm/src/helpers/namespaceColumn.js

@@ -0,0 +1,5 @@
+export default function namespaceColumn(column, alias) {
+    if (column.includes('.'))
+        return column;
+    return `${alias}.${column}`;
+}

package/dist/esm/src/helpers/objectPathsToArrays.js

@@ -0,0 +1,16 @@
+export default function objectPathsToArrays(obj) {
+    const completePaths = [];
+    const workingPath = [];
+    depthFirstSearch(obj, workingPath, completePaths);
+    return completePaths;
+}
+function depthFirstSearch(obj, workingPath, completePaths) {
+    return Object.keys(obj).forEach(key => {
+        if (Object.keys(obj[key]).length) {
+            depthFirstSearch(obj[key], [...workingPath, key], completePaths);
+        }
+        else {
+            completePaths.push([...workingPath, key]);
+        }
+    });
+}

package/dist/esm/src/helpers/pascalize.js

@@ -0,0 +1,9 @@
+import stringCase from './stringCasing.js';
+import { camelizeString } from './camelize.js';
+import capitalize from './capitalize.js';
+export default function pascalize(target) {
+    return stringCase(target, pascalizeString);
+}
+function pascalizeString(str) {
+    return capitalize(camelizeString(str));
+}

package/dist/esm/src/helpers/pascalizePath.js

@@ -0,0 +1,7 @@
+import pascalize from './pascalize.js';
+export default function pascalizePath(path) {
+    return path
+        .split('/')
+        .map(namePart => pascalize(namePart))
+        .join('');
+}

package/dist/esm/src/helpers/path/dreamFileAndDirPaths.js

@@ -0,0 +1,13 @@
+import * as path from 'path';
+import DreamApplication from '../../dream-application/index.js';
+export default function (relDirPath, partialFilePath) {
+    const dreamApp = DreamApplication.getOrFail();
+    const relFilePath = path.join(relDirPath, partialFilePath);
+    const absFilePath = path.join(dreamApp.projectRoot, relFilePath);
+    const absDirPath = absFilePath.replace(/\/[^/]+$/, '');
+    return {
+        relFilePath,
+        absDirPath,
+        absFilePath,
+    };
+}

package/dist/esm/src/helpers/path/dreamPath.js

@@ -0,0 +1,22 @@
+import DreamApplication from '../../dream-application/index.js';
+export default function (dreamPathType) {
+    const dreamApp = DreamApplication.getOrFail();
+    switch (dreamPathType) {
+        case 'models':
+            return dreamApp.paths.models;
+        case 'serializers':
+            return dreamApp.paths.serializers;
+        case 'db':
+            return dreamApp.paths.db;
+        case 'conf':
+            return dreamApp.paths.conf;
+        case 'modelSpecs':
+            return dreamApp.paths.modelSpecs;
+        case 'factories':
+            return dreamApp.paths.factories;
+        case 'types':
+            return dreamApp.paths.types;
+        case 'services':
+            return dreamApp.paths.services;
+    }
+}

package/dist/esm/src/helpers/path/relativeDreamPath.js

@@ -0,0 +1,46 @@
+import pascalize from '../pascalize.js';
+import standardizeFullyQualifiedModelName from '../standardizeFullyQualifiedModelName.js';
+import dreamPath from './dreamPath.js';
+import sharedPathPrefix from './sharedPathPrefix.js';
+export default function (originDreamPathType, destinationDreamPathType, fullyQualifiedOriginModelName, fullyQualifiedDestinationModelName = fullyQualifiedOriginModelName) {
+    fullyQualifiedOriginModelName = standardizeFullyQualifiedModelName(fullyQualifiedOriginModelName);
+    fullyQualifiedDestinationModelName = pascalize(fullyQualifiedDestinationModelName);
+    let pathToRemove = fullyQualifiedOriginModelName;
+    if (originDreamPathType === destinationDreamPathType) {
+        const sharedPrefixLength = sharedPathPrefix(fullyQualifiedOriginModelName, fullyQualifiedDestinationModelName).length;
+        pathToRemove = fullyQualifiedOriginModelName.slice(sharedPrefixLength);
+        fullyQualifiedDestinationModelName = fullyQualifiedDestinationModelName.slice(sharedPrefixLength);
+    }
+    const numAdditionalUpdirs = pathToRemove.split('/').length - 1;
+    let additionalUpdirs = '';
+    for (let i = 0; i < numAdditionalUpdirs; i++) {
+        additionalUpdirs = `../${additionalUpdirs}`;
+    }
+    const baseRelativePath = dreamPathTypeRelativePath(originDreamPathType, destinationDreamPathType);
+    let destinationPath = additionalUpdirs + (baseRelativePath.length ? baseRelativePath + '/' : '');
+    if (destinationPath[0] !== '.')
+        destinationPath = `./${destinationPath}`;
+    switch (destinationDreamPathType) {
+        case 'db':
+            return destinationPath;
+        case 'factories':
+            return `${destinationPath}${fullyQualifiedDestinationModelName}Factory`;
+        case 'serializers':
+            return `${destinationPath}${fullyQualifiedDestinationModelName}Serializer`;
+        default:
+            return `${destinationPath}${fullyQualifiedDestinationModelName}`;
+    }
+}
+export function dreamPathTypeRelativePath(originDreamPathType, destinationDreamPathType) {
+    const originPath = dreamPath(originDreamPathType);
+    const destinationPath = dreamPath(destinationDreamPathType);
+    const sharedPrefixLength = sharedPathPrefix(originPath, destinationPath).length;
+    const originPathToRemove = originPath.slice(sharedPrefixLength);
+    const updirs = originPathToRemove.length === 0
+        ? ''
+        : originPathToRemove
+            .split('/')
+            .map(() => '../')
+            .join('');
+    return updirs + destinationPath.slice(sharedPrefixLength);
+}

package/dist/esm/src/helpers/path/sharedPathPrefix.js

@@ -0,0 +1,11 @@
+export default function (a, b) {
+    const maxLength = Math.max(a.length, b.length);
+    let lastDelimiterIndex = 0;
+    for (let i = 0; i < maxLength; i++) {
+        if (a[i] !== b[i])
+            return a.slice(0, lastDelimiterIndex);
+        if (a[i] === '/')
+            lastDelimiterIndex = i + 1;
+    }
+    return a;
+}

package/dist/esm/src/helpers/propertyNameFromFullyQualifiedModelName.js

@@ -0,0 +1,5 @@
+import standardizeFullyQualifiedModelName from './standardizeFullyQualifiedModelName.js';
+import uncapitalize from './uncapitalize.js';
+export default function (str) {
+    return uncapitalize(standardizeFullyQualifiedModelName(str).replace(/\//g, ''));
+}

package/dist/esm/src/helpers/protectAgainstPollutingAssignment.js

@@ -0,0 +1,11 @@
+import PrototypePollutingAssignment from '../errors/PrototypePollutingAssignment.js';
+const reservedKeys = new Map([
+    ['__proto__', true],
+    ['constructor', true],
+    ['prototype', true],
+]);
+export default function protectAgainstPollutingAssignment(key) {
+    if (reservedKeys.get(key))
+        throw new PrototypePollutingAssignment(key);
+    return key;
+}

package/dist/esm/src/helpers/range.js

@@ -0,0 +1,15 @@
+export default function range(begin, end = null, excludeEnd = false) {
+    return new Range(begin, end, excludeEnd);
+}
+export class Range {
+    begin;
+    end;
+    excludeEnd;
+    constructor(begin, end = null, excludeEnd = false) {
+        this.begin = begin;
+        this.end = end;
+        this.excludeEnd = excludeEnd;
+        if (!begin && !end)
+            throw new Error('Must pass either begin or end to a date range');
+    }
+}

package/dist/esm/src/helpers/round.js

@@ -0,0 +1,4 @@
+export default function round(num, precision = 0) {
+    const multiplier = Math.pow(10, precision) || 1;
+    return Math.round(num * multiplier) / multiplier;
+}

package/dist/esm/src/helpers/serializerNameFromFullyQualifiedModelName.js

@@ -0,0 +1,10 @@
+import standardizeFullyQualifiedModelName from './standardizeFullyQualifiedModelName.js';
+export default function (fullyQualifiedModelName, serializerType = 'default') {
+    fullyQualifiedModelName = standardizeFullyQualifiedModelName(fullyQualifiedModelName);
+    switch (serializerType) {
+        case 'default':
+            return `${fullyQualifiedModelName}Serializer`;
+        case 'summary':
+            return `${fullyQualifiedModelName}SummarySerializer`;
+    }
+}

package/dist/esm/src/helpers/snakeify.js

@@ -0,0 +1,10 @@
+import stringCase from './stringCasing.js';
+import { camelizeString } from './camelize.js';
+export default function snakeify(target) {
+    return stringCase(target, snakeifyString);
+}
+export function snakeifyString(str) {
+    return camelizeString(str)
+        .replace(/([,./<>?;':"[\]{}\\|!@#$%^&*()`])([A-Z])/g, (_, x, y) => x + y.toLowerCase())
+        .replace(/([A-Z])/g, (_, y) => '_' + y.toLowerCase());
+}

package/dist/esm/src/helpers/sortBy.js

@@ -0,0 +1,26 @@
+export default function sortBy(array, valueToCompare) {
+    const arrayClone = [...array];
+    return arrayClone.sort((a, b) => {
+        const aPrime = valueToCompare(a);
+        const bPrime = valueToCompare(b);
+        if (typeof aPrime === 'string' && typeof bPrime === 'string')
+            return aPrime.localeCompare(bPrime);
+        if (typeof aPrime === 'number' && typeof bPrime === 'number')
+            return aPrime - bPrime;
+        if (typeof aPrime === 'bigint' && typeof bPrime === 'bigint')
+            return aPrime.toString().localeCompare(bPrime.toString());
+        throw new UnsupportedValueFromComparisonFunction(aPrime, bPrime);
+    });
+}
+export class UnsupportedValueFromComparisonFunction extends Error {
+    aPrime;
+    bPrime;
+    constructor(aPrime, bPrime) {
+        super();
+        this.aPrime = aPrime;
+        this.bPrime = bPrime;
+    }
+    get message() {
+        return `Value incompatible with compare: ${this.aPrime}, ${this.bPrime}`;
+    }
+}

package/dist/esm/src/helpers/sqlAttributes.js

@@ -0,0 +1,25 @@
+import { DateTime } from 'luxon';
+import CalendarDate from './CalendarDate.js';
+import isDateTimeColumn from './db/types/isDateTimeColumn.js';
+import { isString } from './typechecks.js';
+export default function sqlAttributes(dream) {
+    const attributes = dream.dirtyAttributes();
+    return Object.keys(attributes).reduce((result, key) => {
+        let val = attributes[key];
+        if (isString(val) && isDateTimeColumn(dream.constructor, key))
+            val = DateTime.fromISO(val, { zone: 'UTC' });
+        if (val instanceof DateTime || val instanceof CalendarDate) {
+            // Converting toJSDate resulted in the correct timezone, but even with process.env.TZ=UTC,
+            // Kysely inserted into the database with the machine timezone, which can shift the date
+            // (e.g., toJSDate resulted in a JS Date that formats as "1987-04-07T00:00:00.000Z", but
+            // Kysely inserted "1907-04-06"  into the database). By converting to an SQL string before
+            // handing off to Kysely, we bypass Javascript dates altogether, sending the string into the
+            // database for storage as a date or datetime.
+            result[key] = val.toSQL();
+        }
+        else if (val !== undefined) {
+            result[key] = val;
+        }
+        return result;
+    }, {});
+}

package/dist/esm/src/helpers/sspawn.js

@@ -0,0 +1,17 @@
+import { spawn } from 'child_process';
+export default function sspawn(command, opts = {}) {
+    return new Promise((accept, reject) => {
+        ssspawn(command, opts).on('close', code => {
+            if (code !== 0)
+                reject(new Error(code?.toString()));
+            accept({});
+        });
+    });
+}
+export function ssspawn(command, opts = {}) {
+    return spawn(command, {
+        stdio: 'inherit',
+        shell: true,
+        ...opts,
+    });
+}

package/dist/esm/src/helpers/standardizeFullyQualifiedModelName.js

@@ -0,0 +1,7 @@
+import pascalize from './pascalize.js';
+export default function (str) {
+    return str
+        .split('/')
+        .map(part => pascalize(part))
+        .join('/');
+}

package/dist/esm/src/helpers/stringCasing.js

@@ -0,0 +1,31 @@
+import { DateTime } from 'luxon';
+import { isObject, isString } from './typechecks.js';
+import CalendarDate from './CalendarDate.js';
+export default function stringCase(target, stringCaser) {
+    if (isString(target))
+        return stringCaser(target);
+    return recursiveStringCase(target, stringCaser);
+}
+function recursiveStringCase(target, stringCaser) {
+    if (target === null)
+        return null;
+    if (target === undefined)
+        return undefined;
+    if (isString(target))
+        return target;
+    if (Array.isArray(target))
+        return target.map(s => recursiveStringCase(s, stringCaser));
+    if (isObject(target)) {
+        if (target instanceof DateTime)
+            return target;
+        if (target instanceof CalendarDate)
+            return target;
+        if (target?.isDreamInstance)
+            return target;
+        return Object.keys(target).reduce((stringCasedObject, targetKey) => {
+            stringCasedObject[stringCaser(targetKey)] = recursiveStringCase(target[targetKey], stringCaser);
+            return stringCasedObject;
+        }, {});
+    }
+    return target;
+}

package/dist/esm/src/helpers/typechecks.js

@@ -0,0 +1,12 @@
+export function isString(x) {
+    return typeof x === 'string' || x instanceof String;
+}
+export function isObject(x) {
+    if (x === null)
+        return false;
+    if (isString(x))
+        return false;
+    if (Array.isArray(x))
+        return false;
+    return typeof x === 'object';
+}

package/dist/esm/src/helpers/typeutils.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/src/helpers/uncapitalize.js

@@ -0,0 +1,3 @@
+export default function uncapitalize(str) {
+    return str.slice(0, 1).toLowerCase() + str.slice(1);
+}