@nshiab/simple-data-analysis-core 2.1.11 → 2.1.13

package/script/helpers/cacheTableDependencies.js

@@ -1,275 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.captureCacheTableOperation = captureCacheTableOperation;
-exports.assertCacheTableMutation = assertCacheTableMutation;
-exports.recordCacheTableCreation = recordCacheTableCreation;
-exports.recordCacheTableOperation = recordCacheTableOperation;
-exports.recordCacheTableAccess = recordCacheTableAccess;
-exports.recordCacheTableReferences = recordCacheTableReferences;
-exports.captureCacheTableDependencies = captureCacheTableDependencies;
-exports.cacheTableDependenciesMatch = cacheTableDependenciesMatch;
-exports.changedCacheTableDependenciesMessage = changedCacheTableDependenciesMessage;
-exports.unchangedCacheTableDependenciesMessage = unchangedCacheTableDependenciesMessage;
-const node_async_hooks_1 = require("node:async_hooks");
-const referencedTables_js_1 = __importDefault(require("./referencedTables.js"));
-const asyncOperationContext_js_1 = require("./asyncOperationContext.js");
-const flushAllTables_js_1 = __importStar(require("./flushAllTables.js"));
-const quoteIdentifier_js_1 = __importDefault(require("./quoteIdentifier.js"));
-const tableRegistry_js_1 = require("./tableRegistry.js");
-const tableGeneration_js_1 = require("./tableGeneration.js");
-const dependencyContext = new node_async_hooks_1.AsyncLocalStorage();
-/** Keeps deferred callbacks in their originating cache scope across observers. */
-function captureCacheTableOperation(op) {
-    if (op.kind === "barrier" || op.kind === "asyncBarrier") {
-        return { ...op, execute: bindCacheContext(op.execute) };
-    }
-    if (op.kind === "source") {
-        return { ...op, buildSelect: bindCacheContext(op.buildSelect) };
-    }
-    return {
-        ...op,
-        buildSelect: bindCacheContext(op.buildSelect),
-        outputSchema: op.outputSchema === undefined
-            ? undefined
-            : bindCacheContext(op.outputSchema),
-        values: typeof op.values === "function"
-            ? bindCacheContext(op.values)
-            : op.values,
-    };
-}
-function bindCacheContext(callback) {
-    // Capture only the cache scope: a snapshot of all AsyncLocalStorage stores
-    // would also capture stale flush exemptions and async operation frames.
-    // An empty scope keeps unrelated work out of the observer's cache callback.
-    const frames = dependencyContext.getStore() ?? [];
-    return (...args) => dependencyContext.run(frames, () => callback(...args));
-}
-/** Rejects mutations before they can queue work or execute SQL. */
-function assertCacheTableMutation(table) {
-    for (const frame of dependencyContext.getStore() ?? []) {
-        if (frame.open && table !== frame.cachedTable &&
-            frame.availableBeforeCompute.has(table)) {
-            throw new Error(cacheTableMutationMessage(frame.cachedTable, [table.name]));
-        }
-    }
-}
-/** Tracks callback-owned handles so failure cleanup does not touch other work. */
-function recordCacheTableCreation(table) {
-    for (const frame of dependencyContext.getStore() ?? []) {
-        if (frame.open && table.sdb === frame.cachedTable.sdb &&
-            !frame.availableBeforeCompute.has(table)) {
-            frame.created.add(table);
-        }
-    }
-}
-/** Tracks queued work across nested callbacks, including async barriers. */
-function recordCacheTableOperation(table, op) {
-    for (const frame of dependencyContext.getStore() ?? []) {
-        if (frame.open && table.sdb === frame.cachedTable.sdb) {
-            frame.queued.add(op.sequence);
-        }
-    }
-}
-/** Records a table read when a cache computation is observing dependencies. */
-function recordCacheTableAccess(table) {
-    for (const frame of dependencyContext.getStore() ?? []) {
-        if (frame.open && table.sdb === frame.cachedTable.sdb) {
-            frame.accessed.add(table);
-        }
-    }
-}
-/** Records registered tables named in user-supplied SQL fragments. */
-function recordCacheTableReferences(table, sql) {
-    if (dependencyContext.getStore() === undefined) {
-        return;
-    }
-    for (const candidate of (0, referencedTables_js_1.default)(sql, table.sdb)) {
-        recordCacheTableAccess(candidate);
-    }
-}
-/** Runs a cache computation while collecting the tables it reads. */
-async function captureCacheTableDependencies(cachedTable, compute) {
-    const availableBeforeCompute = new Map((0, tableRegistry_js_1.getRegisteredTables)(cachedTable.sdb).map((table) => [
-        table,
-        {
-            tableName: table.name,
-            generationId: (0, tableGeneration_js_1.peekTableGeneration)(table),
-        },
-    ]));
-    const accessed = new Set();
-    const frame = {
-        cachedTable,
-        availableBeforeCompute,
-        accessed,
-        created: new Set(),
-        queued: new Set(),
-        open: true,
-    };
-    try {
-        await dependencyContext.run([...(dependencyContext.getStore() ?? []), frame], async () => {
-            await compute();
-            // A callback can queue a whole computation without observing it.
-            // Reject leaked handles before executing that pending computation.
-            assertCacheTableCleanup(frame);
-            await (0, flushAllTables_js_1.default)(cachedTable.sdb);
-            // Async barriers may create tables during the final flush.
-            assertCacheTableCleanup(frame);
-        });
-    }
-    catch (error) {
-        await cleanupCacheComputation(frame);
-        throw error;
-    }
-    finally {
-        frame.open = false;
-    }
-    return [...accessed]
-        .filter((table) => table !== cachedTable && availableBeforeCompute.has(table))
-        .map((table) => {
-        const snapshot = availableBeforeCompute.get(table);
-        if (snapshot === undefined) {
-            throw new Error("A cache table dependency snapshot is missing.");
-        }
-        return {
-            tableName: snapshot.tableName,
-            generationId: snapshot.generationId ?? (0, tableGeneration_js_1.getTableGeneration)(table),
-        };
-    })
-        .sort((left, right) => left.tableName.localeCompare(right.tableName));
-}
-function assertCacheTableCleanup(frame) {
-    const created = (0, tableRegistry_js_1.getRegisteredTables)(frame.cachedTable.sdb)
-        .filter((table) => frame.created.has(table));
-    if (created.length > 0) {
-        throw new Error(cacheTableCleanupMessage(created.map((table) => table.name)));
-    }
-}
-async function cleanupCacheComputation(frame) {
-    const sdb = frame.cachedTable.sdb;
-    // Drop only this callback's pending operations, preserving other queues and
-    // their database-wide ordering. A nested failure also discards work captured
-    // by an enclosing async barrier, which is stored outside pendingOps.
-    for (const table of (0, tableRegistry_js_1.getRegisteredTables)(sdb)) {
-        const retained = table.pendingOps.filter((op) => !frame.queued.has(op.sequence));
-        sdb.pendingCount -= table.pendingOps.length - retained.length;
-        table.pendingOps.splice(0, table.pendingOps.length, ...retained);
-    }
-    const operationFrame = (0, asyncOperationContext_js_1.getAsyncOperationFrame)(sdb);
-    if (operationFrame !== undefined) {
-        operationFrame.entries = operationFrame.entries.filter((entry) => !frame.queued.has(entry.op.sequence));
-    }
-    const created = (0, tableRegistry_js_1.getRegisteredTables)(sdb)
-        .filter((table) => frame.created.has(table));
-    if (created.length === 0)
-        return;
-    // Observers inside compute may already have materialized temporary tables.
-    // Cleanup must not flush work requeued after an execution error.
-    const removeCreatedTables = () => (0, flushAllTables_js_1.runExemptFromFlush)(sdb, async () => {
-        for (const table of created) {
-            await sdb.customQuery(`DROP TABLE IF EXISTS ${(0, quoteIdentifier_js_1.default)(table.name)};`);
-        }
-    });
-    if (operationFrame === undefined) {
-        await removeCreatedTables();
-    }
-    else {
-        // Async frames take precedence over the database-wide flush exemption.
-        // Suppress their drain too, without consuming unrelated captured work.
-        await (0, asyncOperationContext_js_1.runWhileDrainingAsyncOperationFrame)(operationFrame, removeCreatedTables);
-    }
-    (0, tableRegistry_js_1.retainRegisteredTables)(sdb, (table) => !frame.created.has(table));
-}
-function cacheTableMutationMessage(cachedTable, changedTables) {
-    const tables = changedTables.map((name) => JSON.stringify(name)).join(", ");
-    const cachedTableName = JSON.stringify(cachedTable.name);
-    if (changedTables.length === 1) {
-        return `cache() called on ${cachedTableName} cannot modify pre-existing table ${tables}. Modify ${tables} outside this cache() call.`;
-    }
-    return `cache() called on ${cachedTableName} cannot modify pre-existing tables ${tables}. Modify these tables outside this cache() call.`;
-}
-function cacheTableCleanupMessage(createdTables) {
-    const tables = createdTables.map((name) => JSON.stringify(name)).join(", ");
-    if (createdTables.length === 1) {
-        return `cache() created table ${tables} but did not remove it. Call removeTable() on ${tables} before the callback finishes to avoid downstream errors when the cache is loaded and this table is not recreated.`;
-    }
-    return `cache() created tables ${tables} but did not remove them. Call removeTable() on these tables before the callback finishes to avoid downstream errors when the cache is loaded and these tables are not recreated.`;
-}
-/** Checks persisted dependencies against the current registered tables. */
-function cacheTableDependenciesMatch(cachedTable, dependencies) {
-    if (dependencies === undefined) {
-        return false;
-    }
-    const registered = (0, tableRegistry_js_1.getRegisteredTables)(cachedTable.sdb);
-    return dependencies.every((dependency) => {
-        const table = registered.find((candidate) => candidate.name === dependency.tableName);
-        return table !== undefined &&
-            (0, tableGeneration_js_1.getTableGeneration)(table) === dependency.generationId;
-    });
-}
-/** Describes changed or unavailable table dependencies for verbose logging. */
-function changedCacheTableDependenciesMessage(cachedTable, dependencies) {
-    const registered = (0, tableRegistry_js_1.getRegisteredTables)(cachedTable.sdb);
-    const changed = [];
-    const unchanged = [];
-    for (const dependency of dependencies) {
-        const table = registered.find((candidate) => candidate.name === dependency.tableName);
-        if (table === undefined ||
-            (0, tableGeneration_js_1.getTableGeneration)(table) !== dependency.generationId) {
-            changed.push(dependency);
-        }
-        else {
-            unchanged.push(dependency);
-        }
-    }
-    return [
-        cacheTableDependencyStatusMessage("changed", changed),
-        cacheTableDependencyStatusMessage("unchanged", unchanged),
-    ].filter((message) => message.length > 0).join("\n");
-}
-/** Lists unchanged dependencies for cache-hit verbose logging. */
-function unchangedCacheTableDependenciesMessage(dependencies) {
-    return cacheTableDependencyStatusMessage("unchanged", dependencies);
-}
-function cacheTableDependencyStatusMessage(status, dependencies) {
-    if (dependencies.length === 0) {
-        return "";
-    }
-    return `Table dependencies ${status}: ${dependencies.map((dependency) => JSON.stringify(dependency.tableName))
-        .join(", ")}.`;
-}

package/script/helpers/camelCase.d.ts

@@ -1,32 +0,0 @@
-/**
- * Converts a string into camelCase. This is useful for creating variable
- * names or object keys from human-readable text.
- *
- * @example
- * ```ts
- * // Basic conversion
- * const result1 = camelCase("hello world");
- * console.log(result1); // "helloWorld"
- * ```
- *
- * @example
- * ```ts
- * // With punctuation and mixed case
- * const result2 = camelCase("  --Some@Thing is- happening--  ");
- * console.log(result2); // "someThingIsHappening"
- * ```
- *
- * @example
- * ```ts
- * // With a single word
- * const result3 = camelCase("Journalism");
- * console.log(result3); // "journalism"
- * ```
- *
- * @param input - The string to convert to camelCase. It can contain spaces,
- *   punctuation, and mixed casing.
- *
- * @returns The camelCased version of the input string.
- */
-export default function camelCase(input: string): string;
-//# sourceMappingURL=camelCase.d.ts.map

package/script/helpers/camelCase.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"camelCase.d.ts","sourceRoot":"","sources":["../../src/helpers/camelCase.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,CAAC,OAAO,UAAU,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAiBvD"}

package/script/helpers/camelCase.js

@@ -1,53 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = camelCase;
-const capitalize_js_1 = __importDefault(require("./capitalize.js"));
-/**
- * Converts a string into camelCase. This is useful for creating variable
- * names or object keys from human-readable text.
- *
- * @example
- * ```ts
- * // Basic conversion
- * const result1 = camelCase("hello world");
- * console.log(result1); // "helloWorld"
- * ```
- *
- * @example
- * ```ts
- * // With punctuation and mixed case
- * const result2 = camelCase("  --Some@Thing is- happening--  ");
- * console.log(result2); // "someThingIsHappening"
- * ```
- *
- * @example
- * ```ts
- * // With a single word
- * const result3 = camelCase("Journalism");
- * console.log(result3); // "journalism"
- * ```
- *
- * @param input - The string to convert to camelCase. It can contain spaces,
- *   punctuation, and mixed casing.
- *
- * @returns The camelCased version of the input string.
- */
-function camelCase(input) {
-    const words = input
-        .replace(/[^a-zA-Z0-9\s]/g, " ")
-        .split(/\s+/)
-        .filter((d) => d !== "");
-    const camelCaseString = words
-        .map((word, index) => {
-        word = word.toLowerCase();
-        if (index > 0) {
-            word = (0, capitalize_js_1.default)(word);
-        }
-        return word;
-    })
-        .join("");
-    return camelCaseString;
-}

package/script/helpers/capitalize.d.ts

@@ -1,30 +0,0 @@
-/**
- * Capitalizes the first letter of a given string.
- *
- * @example
- * ```ts
- * // Basic usage
- * const capitalized = capitalize("hello world");
- * console.log(capitalized); // "Hello world"
- * ```
- *
- * @example
- * ```ts
- * // With an already capitalized string
- * const alreadyCapitalized = capitalize("Journalism");
- * console.log(alreadyCapitalized); // "Journalism"
- * ```
- *
- * @example
- * ```ts
- * // With a single character
- * const singleChar = capitalize("a");
- * console.log(singleChar); // "A"
- * ```
- *
- * @param string - The string to be capitalized.
- *
- * @returns A new string with the first letter in uppercase.
- */
-export default function capitalize(string: string): string;
-//# sourceMappingURL=capitalize.d.ts.map

package/script/helpers/capitalize.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"capitalize.d.ts","sourceRoot":"","sources":["../../src/helpers/capitalize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,CAAC,OAAO,UAAU,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAMzD"}

package/script/helpers/capitalize.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = capitalize;
-/**
- * Capitalizes the first letter of a given string.
- *
- * @example
- * ```ts
- * // Basic usage
- * const capitalized = capitalize("hello world");
- * console.log(capitalized); // "Hello world"
- * ```
- *
- * @example
- * ```ts
- * // With an already capitalized string
- * const alreadyCapitalized = capitalize("Journalism");
- * console.log(alreadyCapitalized); // "Journalism"
- * ```
- *
- * @example
- * ```ts
- * // With a single character
- * const singleChar = capitalize("a");
- * console.log(singleChar); // "A"
- * ```
- *
- * @param string - The string to be capitalized.
- *
- * @returns A new string with the first letter in uppercase.
- */
-function capitalize(string) {
-    if (string.length === 0) {
-        return string;
-    }
-    const first = string[0];
-    return first.toUpperCase() + string.slice(1);
-}

package/script/helpers/cleanCache.d.ts

@@ -1,3 +0,0 @@
-import type SimpleDB from "../class/SimpleDB.js";
-export default function cleanCache(sdb: SimpleDB, log?: (message: string) => void): void;
-//# sourceMappingURL=cleanCache.d.ts.map

package/script/helpers/cleanCache.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cleanCache.d.ts","sourceRoot":"","sources":["../../src/helpers/cleanCache.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,QAAQ,MAAM,sBAAsB,CAAC;AAEjD,MAAM,CAAC,OAAO,UAAU,UAAU,CAChC,GAAG,EAAE,QAAQ,EACb,GAAG,GAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAkB,QAoB7C"}

package/script/helpers/cleanCache.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = cleanCache;
-const node_fs_1 = require("node:fs");
-function cleanCache(sdb, log = console.log) {
-    if (sdb.cacheSourcesUsed.length > 0) {
-        const cacheSources = JSON.parse((0, node_fs_1.readFileSync)(".sda-cache/sources.json", "utf-8"));
-        for (const cacheId of Object.keys(cacheSources)) {
-            if (!sdb.cacheSourcesUsed.includes(cacheId)) {
-                if (cacheSources[cacheId].file !== null) {
-                    sdb.cacheVerbose &&
-                        log(`Removing unused file from cache: ${cacheSources[cacheId].file}`);
-                    (0, node_fs_1.unlinkSync)(cacheSources[cacheId].file);
-                }
-                delete cacheSources[cacheId];
-            }
-        }
-        (0, node_fs_1.writeFileSync)(".sda-cache/sources.json", JSON.stringify(cacheSources));
-    }
-}

package/script/helpers/cleanPath.d.ts

@@ -1,2 +0,0 @@
-export default function cleanPath(file: string): string;
-//# sourceMappingURL=cleanPath.d.ts.map

package/script/helpers/cleanPath.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cleanPath.d.ts","sourceRoot":"","sources":["../../src/helpers/cleanPath.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,SAAS,CAAC,IAAI,EAAE,MAAM,UAE7C"}

package/script/helpers/cleanPath.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = cleanPath;
-function cleanPath(file) {
-    return file.replaceAll("'", "''");
-}

package/script/helpers/cleanSQL.d.ts

@@ -1,2 +0,0 @@
-export default function cleanSQL(query: string, syntax?: "js" | "sql"): string;
-//# sourceMappingURL=cleanSQL.d.ts.map

package/script/helpers/cleanSQL.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cleanSQL.d.ts","sourceRoot":"","sources":["../../src/helpers/cleanSQL.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,UAAU,QAAQ,CAC9B,KAAK,EAAE,MAAM,EACb,MAAM,GAAE,IAAI,GAAG,KAAY,GAC1B,MAAM,CAqRR"}