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

package/esm/helpers/findGeoColumnFromSchema.js

@@ -1,31 +0,0 @@
-import quoteIdentifier from "./quoteIdentifier.js";
-/**
- * Returns the only geometry column in a table schema.
- *
- * @example
- * ```ts
- * const column = findGeoColumnFromSchema(
- *   { geom: "GEOMETRY('EPSG:4326')" },
- *   "area()",
- *   "places",
- * );
- * ```
- *
- * @param types - The table schema to inspect.
- *
- * @param method - The SDA method requesting a geometry column.
- *
- * @param tableName - The name of the table represented by the schema.
- *
- * @returns The name of the only geometry column.
- */
-export default function findGeoColumnFromSchema(types, method, tableName) {
-    const geometryColumns = Object.keys(types).filter((column) => types[column].toLowerCase().includes("geometry")).sort();
-    if (geometryColumns.length === 0) {
-        throw new Error(`${method} could not find a geometry column in table ${quoteIdentifier(tableName)}. Specify a geometry column explicitly, or add one to the table first.`);
-    }
-    else if (geometryColumns.length > 1) {
-        throw new Error(`${method} found ${geometryColumns.length} geometry columns in table ${quoteIdentifier(tableName)}: ${geometryColumns.map(quoteIdentifier).join(", ")}. Specify one explicitly.`);
-    }
-    return geometryColumns[0];
-}

package/esm/helpers/fitUmapCurve.d.ts

@@ -1,2 +0,0 @@
-export default function fitUmapCurve(minDistance: number): [number, number];
-//# sourceMappingURL=fitUmapCurve.d.ts.map

package/esm/helpers/fitUmapCurve.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fitUmapCurve.d.ts","sourceRoot":"","sources":["../../src/helpers/fitUmapCurve.ts"],"names":[],"mappings":"AAGA,MAAM,CAAC,OAAO,UAAU,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CA2D1E"}

package/esm/helpers/fitUmapCurve.js

@@ -1,66 +0,0 @@
-// Least-squares fit of 1/(1+a*x^(2*b)) to the reference UMAP target curve.
-// Spread is fixed to one. See umap-learn's find_ab_params (0.5.9.post2).
-// A two-parameter damped Gauss-Newton solve avoids a runtime fitting dependency.
-export default function fitUmapCurve(minDistance) {
-    if (!Number.isFinite(minDistance) || minDistance < 0 || minDistance > 1) {
-        throw new Error("minDistance must be between zero and one.");
-    }
-    const samples = Array.from({ length: 299 }, (_, i) => {
-        const x = (i + 1) * 3 / 299;
-        return {
-            logX: Math.log(x),
-            target: Math.exp(-Math.max(0, x - minDistance)),
-        };
-    });
-    const loss = (logA, logB) => {
-        let sum = 0;
-        for (const { logX, target } of samples) {
-            const residual = 1 / (1 + Math.exp(logA + 2 * Math.exp(logB) * logX)) -
-                target;
-            sum += residual * residual;
-        }
-        return sum;
-    };
-    let logA = 0, logB = 0, damping = 1e-3;
-    let error = loss(logA, logB);
-    for (let iteration = 0; iteration < 100; iteration++) {
-        let aa = 0, ab = 0, bb = 0, ga = 0, gb = 0;
-        for (const { logX, target } of samples) {
-            const power = Math.exp(logA + 2 * Math.exp(logB) * logX);
-            const predicted = 1 / (1 + power);
-            const da = -power * predicted * predicted;
-            const db = da * 2 * Math.exp(logB) * logX;
-            aa += da * da;
-            ab += da * db;
-            bb += db * db;
-            ga += da * (predicted - target);
-            gb += db * (predicted - target);
-        }
-        const aDiagonal = aa + damping * Math.max(aa, 1e-12);
-        const bDiagonal = bb + damping * Math.max(bb, 1e-12);
-        const determinant = aDiagonal * bDiagonal - ab * ab;
-        if (!(determinant > 0))
-            throw new Error("UMAP curve fit became singular.");
-        const stepA = (ab * gb - bDiagonal * ga) / determinant;
-        const stepB = (ab * ga - aDiagonal * gb) / determinant;
-        const nextA = Math.max(-20, Math.min(20, logA + stepA));
-        const nextB = Math.max(-20, Math.min(20, logB + stepB));
-        const nextError = loss(nextA, nextB);
-        if (nextError < error) {
-            const improvement = error - nextError;
-            logA = nextA;
-            logB = nextB;
-            error = nextError;
-            damping = Math.max(damping / 3, 1e-12);
-            if (improvement < 1e-13)
-                return [Math.exp(logA), Math.exp(logB)];
-        }
-        else {
-            damping *= 10;
-            if (Math.max(Math.abs(ga), Math.abs(gb)) < 1e-7) {
-                return [Math.exp(logA), Math.exp(logB)];
-            }
-        }
-    }
-    throw new Error("UMAP curve fit did not converge.");
-}

package/esm/helpers/flushAllTables.d.ts

@@ -1,23 +0,0 @@
-import type SimpleDB from "../class/SimpleDB.js";
-/**
- * Runs `fn` with `sdb` exempt from the top-level flush. Queries issued by an
- * asynchronous barrier can still drain operations queued inside that barrier.
- * Used by the flush itself and by connection setup, whose queries must run
- * before any queued operation.
- */
-export declare function runExemptFromFlush<T>(sdb: SimpleDB, fn: () => Promise<T>): Promise<T>;
-/**
- * Executes the pending operations of all tables in program order: every
- * queued operation carries a database-wide sequence number, so operations
- * on different tables replay exactly in the order the user queued them,
- * like immediate execution would. Consecutive fusable operations on the
- * same table compose as CTEs into a single statement; barriers execute
- * in order between fused segments.
- *
- * Every query execution point goes through this (via queryDB). Only one
- * flush runs at a time: concurrent observers wait for the in-flight flush,
- * then flush whatever queued in the meantime, so an awaited observer always
- * answers from fully executed state.
- */
-export default function flushAllTables(sdb: SimpleDB): Promise<void>;
-//# sourceMappingURL=flushAllTables.d.ts.map

package/esm/helpers/flushAllTables.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"flushAllTables.d.ts","sourceRoot":"","sources":["../../src/helpers/flushAllTables.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,QAAQ,MAAM,sBAAsB,CAAC;AAkCjD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,GAAG,EAAE,QAAQ,EACb,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,CAAC,CAAC,CAIZ;AAED;;;;;;;;;;;;GAYG;AACH,wBAA8B,cAAc,CAAC,GAAG,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAgCzE"}

package/esm/helpers/flushAllTables.js

@@ -1,406 +0,0 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-import cleanSQL from "./cleanSQL.js";
-import referencedTables from "./referencedTables.js";
-import ensureSpatial from "./ensureSpatial.js";
-import extractTypes from "./extractTypes.js";
-import mergeOptions from "./mergeOptions.js";
-import queryDB from "./queryDB.js";
-import quoteIdentifier from "./quoteIdentifier.js";
-import { getRegisteredTables } from "./tableRegistry.js";
-import { getAsyncOperationFrame, isDrainingAsyncOperationFrame, runWhileDrainingAsyncOperationFrame, runWithAsyncOperationFrame, } from "./asyncOperationContext.js";
-/**
- * The databases whose flush is executing on the current async call chain.
- * Queries issued by the flush itself (fused statements, barriers, DESCRIBE)
- * re-enter flushAllTables through queryDB and must not trigger a new flush,
- * while queries from concurrent observers must wait for the in-flight flush
- * instead of reading mid-flush state.
- */
-const flushContext = new AsyncLocalStorage();
-/**
- * Runs `fn` with `sdb` exempt from the top-level flush. Queries issued by an
- * asynchronous barrier can still drain operations queued inside that barrier.
- * Used by the flush itself and by connection setup, whose queries must run
- * before any queued operation.
- */
-export function runExemptFromFlush(sdb, fn) {
-    const exempt = new Set(flushContext.getStore());
-    exempt.add(sdb);
-    return flushContext.run(exempt, fn);
-}
-/**
- * Executes the pending operations of all tables in program order: every
- * queued operation carries a database-wide sequence number, so operations
- * on different tables replay exactly in the order the user queued them,
- * like immediate execution would. Consecutive fusable operations on the
- * same table compose as CTEs into a single statement; barriers execute
- * in order between fused segments.
- *
- * Every query execution point goes through this (via queryDB). Only one
- * flush runs at a time: concurrent observers wait for the in-flight flush,
- * then flush whatever queued in the meantime, so an awaited observer always
- * answers from fully executed state.
- */
-export default async function flushAllTables(sdb) {
-    const frame = getAsyncOperationFrame(sdb);
-    if (frame !== undefined) {
-        if (!isDrainingAsyncOperationFrame(frame)) {
-            await drainAsyncOperationFrame(frame);
-        }
-        return;
-    }
-    if (flushContext.getStore()?.has(sdb)) {
-        // A query issued by the top-level flush itself.
-        return;
-    }
-    while (sdb.flushPromise !== null) {
-        // Another observer's flush is running: wait for it instead of reading
-        // mid-flush state, then flush anything queued in the meantime.
-        try {
-            await sdb.flushPromise;
-        }
-        catch {
-            // The error belongs to the observer that started that flush; this
-            // observer only cares that the flush is over.
-        }
-    }
-    if (sdb.pendingCount === 0) {
-        return;
-    }
-    const promise = runExemptFromFlush(sdb, () => flush(sdb));
-    sdb.flushPromise = promise;
-    try {
-        await promise;
-    }
-    finally {
-        sdb.flushPromise = null;
-    }
-}
-async function flush(sdb) {
-    // Take ownership of every queue upfront, in program order.
-    const entries = [];
-    for (const table of getRegisteredTables(sdb)) {
-        for (const op of table.pendingOps.splice(0, table.pendingOps.length)) {
-            entries.push({ table, op });
-        }
-    }
-    sdb.pendingCount = 0;
-    await replayEntries(sdb, entries);
-}
-async function replayEntries(sdb, pendingEntries) {
-    const entries = [...pendingEntries].sort((a, b) => a.op.sequence - b.op.sequence);
-    let open = null;
-    // The table whose operation is executing, for error attribution: on
-    // failure, that table's chain aborts and the other tables' pending work
-    // goes back to their queues.
-    let executing = null;
-    // The entry being dispatched, if it is neither executed nor part of an
-    // open segment yet.
-    let current = null;
-    const runOpenSegment = async () => {
-        if (open === null) {
-            return;
-        }
-        const segment = open;
-        open = null;
-        executing = segment.table;
-        await runSegment(segment.table, segment.ops);
-        executing = null;
-    };
-    let index = 0;
-    try {
-        for (; index < entries.length; index++) {
-            const entry = entries[index];
-            // Release the reference: a consumed operation (and whatever its
-            // closures capture, like loadArray data) must not stay alive for the
-            // rest of the flush.
-            entries[index] = null;
-            current = entry;
-            const { table, op } = entry;
-            if (open !== null && open.table !== table) {
-                await runOpenSegment();
-            }
-            if (op.kind === "barrier") {
-                // A barrier is multi-statement by nature and can read or write any
-                // table, so everything pending executes first.
-                await runOpenSegment();
-                executing = table;
-                await op.execute();
-                executing = null;
-                current = null;
-                continue;
-            }
-            if (op.kind === "asyncBarrier") {
-                // An asynchronous extension barrier also captures and drains builder
-                // operations queued by its callback before replay continues.
-                await runOpenSegment();
-                executing = table;
-                await runAsyncBarrier(table, op);
-                executing = null;
-                current = null;
-                continue;
-            }
-            const reads = op.rawSQL === undefined
-                ? []
-                : referencedTables(op.rawSQL, sdb);
-            if (op.kind === "fusable" && reads.includes(table)) {
-                // User-supplied SQL referencing the operation's own table must read
-                // the state produced by the previous steps, which a fused chain
-                // can't provide (the name would resolve to the pre-chain table). So
-                // the chain materializes and the operation runs on its own.
-                await runOpenSegment();
-                executing = table;
-                await runStepwise(table, op);
-                executing = null;
-                current = null;
-                continue;
-            }
-            const sourceSegment = open;
-            const segmentSource = sourceSegment?.ops[0];
-            if (op.kind === "fusable" &&
-                segmentSource?.kind === "source" &&
-                (op.requiresMaterializedInput ||
-                    (op.needsSpatial && segmentSource.schema === undefined))) {
-                // Materialize only the external source when this operation needs a
-                // stable physical input, or when a spatial operation would otherwise
-                // make DuckDB scan an unknown source once for schema inference and
-                // again for execution. Earlier transforms remain open and fuse with
-                // this operation.
-                const source = segmentSource;
-                const pending = sourceSegment?.ops.slice(1) ?? [];
-                open = null;
-                executing = table;
-                await runSegment(table, [source]);
-                executing = null;
-                open = { table, ops: [...pending, op] };
-                current = null;
-                continue;
-            }
-            if (op.kind === "source") {
-                // A source replaces the target table from an external relation. It
-                // starts a new segment rather than consuming any segment already open
-                // on the same table. A source may read that materialized table itself
-                // (for example, an in-place join) and still fuse with downstream steps.
-                await runOpenSegment();
-                open = { table, ops: [op] };
-                current = null;
-                continue;
-            }
-            if (open === null) {
-                open = { table, ops: [] };
-            }
-            open.ops.push(op);
-            current = null;
-        }
-        await runOpenSegment();
-    }
-    catch (error) {
-        // The failing table's chain aborts, like a v1 script stopping at the
-        // failing line. The other tables' pending work was queued successfully
-        // and goes back to their queues, to execute at their next observation.
-        const failing = executing;
-        const requeue = (table, op) => {
-            if (table !== failing) {
-                table.pendingOps.push(op);
-                sdb.pendingCount++;
-            }
-        };
-        if (current !== null) {
-            requeue(current.table, current.op);
-        }
-        if (open !== null) {
-            for (const op of open.ops) {
-                requeue(open.table, op);
-            }
-        }
-        for (let i = index + 1; i < entries.length; i++) {
-            const entry = entries[i];
-            if (entry !== null) {
-                requeue(entry.table, entry.op);
-            }
-        }
-        throw error;
-    }
-}
-async function runAsyncBarrier(table, op) {
-    await runWithAsyncOperationFrame(table.sdb, async (frame) => {
-        await op.execute();
-        await drainAsyncOperationFrame(frame);
-    });
-}
-async function drainAsyncOperationFrame(frame) {
-    while (frame.drainPromise !== null) {
-        try {
-            await frame.drainPromise;
-        }
-        catch {
-            // The observer that started the drain receives its failure. A concurrent
-            // observer waits for that drain to finish, then handles remaining work.
-        }
-    }
-    if (frame.entries.length === 0) {
-        return;
-    }
-    // Start on the next microtask so drainPromise is visible before replay can
-    // re-enter user code or another observer can attempt the same drain.
-    const promise = Promise.resolve().then(() => runWhileDrainingAsyncOperationFrame(frame, async () => {
-        while (frame.entries.length > 0) {
-            const entries = frame.entries.splice(0, frame.entries.length);
-            await replayEntries(frame.sdb, entries);
-        }
-    }));
-    frame.drainPromise = promise;
-    try {
-        await promise;
-    }
-    finally {
-        if (frame.drainPromise === promise) {
-            frame.drainPromise = null;
-        }
-    }
-}
-async function runSegment(table, ops) {
-    if (ops.length === 1) {
-        await runStepwise(table, ops[0]);
-        return;
-    }
-    if (ops.some(needsSpatial)) {
-        await ensureSpatial(table);
-    }
-    // Normalize each fragment once using the database syntax before composition.
-    const ctes = [];
-    // The schema of the next fragment's input, reused while operations declare
-    // they preserve it, so a run of same-shape steps costs at most one
-    // DESCRIBE round-trip.
-    let schema = null;
-    for (let i = 0; i < ops.length; i++) {
-        const op = ops[i];
-        try {
-            const compiled = await compileOp(table, op, ctes, schema);
-            ctes.push(compiled.cte);
-            schema = compiled.schema;
-        }
-        catch (error) {
-            // Flush-time validation (or a broken earlier fragment surfacing at
-            // DESCRIBE) fails the chain at this operation. The steps before it
-            // already succeeded in program order, so they execute before the
-            // error propagates — like a v1 script failing at this line.
-            if (ctes.length > 0) {
-                await executeFused(table, ops.slice(0, i), ctes);
-            }
-            throw error;
-        }
-    }
-    await executeFused(table, ops, ctes);
-}
-async function compileOp(table, op, ctes, schema) {
-    // Source relations can read tables named s1, s2, etc. A generated CTE must
-    // not shadow those physical inputs, including in later chain fragments.
-    const usedNames = new Set([
-        ...getRegisteredTables(table.sdb).map((input) => input.name.toLowerCase()),
-        ...ctes.map((cte) => cte.alias),
-    ]);
-    let aliasIndex = ctes.length + 1;
-    while (usedNames.has(`s${aliasIndex}`))
-        aliasIndex++;
-    const alias = `s${aliasIndex}`;
-    if (op.kind === "source") {
-        return {
-            cte: {
-                alias,
-                select: cleanSQL(await op.buildSelect(), table.sdb.expressionSyntax),
-                values: [],
-            },
-            schema: op.schema ?? null,
-        };
-    }
-    const input = ctes.length === 0
-        ? quoteIdentifier(table.name)
-        : quoteIdentifier(ctes[ctes.length - 1].alias);
-    const inputSchema = op.needsSchema && schema === null
-        ? await describeChain(table, ctes)
-        : schema;
-    const buildSchema = inputSchema ?? {};
-    const outputSchema = inputSchema === null
-        ? null
-        : op.outputSchema !== undefined
-            ? op.outputSchema(inputSchema)
-            : op.preservesSchema === true
-                ? inputSchema
-                : null;
-    return {
-        cte: {
-            alias,
-            select: cleanSQL(op.buildSelect(input, buildSchema), table.sdb.expressionSyntax),
-            values: resolveValues(op, buildSchema),
-        },
-        schema: outputSchema,
-    };
-}
-async function executeFused(table, ops, ctes) {
-    // A trailing line comment must end before the generated CTE delimiter.
-    const query = `CREATE OR REPLACE TABLE ${quoteIdentifier(table.name)} AS WITH ${ctes.map((c) => `${quoteIdentifier(c.alias)} AS (${c.select}\n)`).join(", ")} SELECT * FROM ${quoteIdentifier(ctes[ctes.length - 1].alias)}`;
-    try {
-        await queryDB(table, query, mergeOptions(table, {
-            table: table.name,
-            method: ops.map((op) => op.method).join(" + "),
-            parameters: Object.fromEntries(ops.map((op, i) => [`${i + 1}. ${op.method}`, op.parameters])),
-            values: ctes.flatMap((cte) => cte.values),
-            noClean: true,
-        }));
-    }
-    catch (fusedError) {
-        // Re-run the segment step by step to pinpoint the culprit method and
-        // report it exactly as immediate execution would have.
-        for (const op of ops) {
-            await runStepwise(table, op);
-        }
-        // Every step succeeded on its own: the failure came from the fusion
-        // itself. The table now holds the correct stepwise result, so we warn
-        // instead of throwing.
-        console.warn(`The fused query for ${ops.map((op) => op.method).join(" + ")} failed, but running the methods one by one succeeded. Please report this as a bug to https://github.com/nshiab/simple-data-analysis-core/issues.\n${fusedError instanceof Error ? fusedError.message : String(fusedError)}`);
-    }
-}
-async function runStepwise(table, op) {
-    if (needsSpatial(op)) {
-        await ensureSpatial(table);
-    }
-    // Compilation is shared with the fused path, so both paths execute the same
-    // cleaned fragment with the same bound values and schema handling.
-    const compiled = await compileOp(table, op, [], null);
-    await queryDB(table, `CREATE OR REPLACE TABLE ${quoteIdentifier(table.name)} AS ${compiled.cte.select}`, mergeOptions(table, {
-        table: table.name,
-        method: op.method,
-        parameters: op.parameters,
-        values: compiled.cte.values,
-        noClean: true,
-    }));
-}
-function needsSpatial(op) {
-    return op.needsSpatial === true;
-}
-function resolveValues(op, schema) {
-    return typeof op.values === "function" ? op.values(schema) : op.values ?? [];
-}
-/**
- * Returns the schema at the current point in the fused chain. With no CTEs
- * yet, this describes the table itself; otherwise it describes the output of
- * the last fragment. DESCRIBE is planning-only, so no data is computed.
- */
-async function describeChain(table, ctes) {
-    const select = ctes.length === 0
-        ? `SELECT * FROM ${quoteIdentifier(table.name)}`
-        : `WITH ${ctes.map((c) => `${quoteIdentifier(c.alias)} AS (${c.select}\n)`).join(", ")} SELECT * FROM ${quoteIdentifier(ctes[ctes.length - 1].alias)}`;
-    const query = ctes.length === 0
-        ? `DESCRIBE ${quoteIdentifier(table.name)}`
-        : `DESCRIBE ${select}`;
-    const values = ctes.flatMap((cte) => cte.values);
-    const types = await queryDB(table, query, mergeOptions(table, {
-        table: table.name,
-        method: null,
-        parameters: null,
-        returnData: true,
-        values,
-        noClean: true,
-    }));
-    return extractTypes(types);
-}

package/esm/helpers/foldIdentifier.d.ts

@@ -1,3 +0,0 @@
-/** Matches DuckDB's ASCII case folding for quoted and unquoted identifiers. */
-export default function foldIdentifier(identifier: string): string;
-//# sourceMappingURL=foldIdentifier.d.ts.map

package/esm/helpers/foldIdentifier.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"foldIdentifier.d.ts","sourceRoot":"","sources":["../../src/helpers/foldIdentifier.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,MAAM,CAAC,OAAO,UAAU,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAEjE"}

package/esm/helpers/foldIdentifier.js

@@ -1,4 +0,0 @@
-/** Matches DuckDB's ASCII case folding for quoted and unquoted identifiers. */
-export default function foldIdentifier(identifier) {
-    return identifier.replace(/[A-Z]/g, (letter) => letter.toLowerCase());
-}

package/esm/helpers/formatDate.d.ts

@@ -1,40 +0,0 @@
-/**
- * Formats a `Date` object into a human-readable string using only the format
- * strings actually used in the project.
- *
- * @example
- * ```ts
- * // Format a date with time (local time).
- * const date = new Date("2023-01-01T01:35:00");
- * const formatted = formatDate(date, "Month DD, YYYY, at HH:MM period");
- * console.log(formatted); // "January 1, 2023, at 1:35 a.m."
- * ```
- *
- * @example
- * ```ts
- * // Format a date as month and day only (UTC).
- * const formatted = formatDate(new Date("2023-01-01"), "Month DD", { utc: true });
- * console.log(formatted); // "January 1"
- * ```
- *
- * @example
- * ```ts
- * // Minutes of ":00" are omitted.
- * const formatted = formatDate(new Date("2023-01-01T01:00:00"), "Month DD, YYYY, at HH:MM period", { utc: true });
- * console.log(formatted); // "January 1, 2023, at 1 a.m."
- * ```
- *
- * @param date - The `Date` object to format.
- *
- * @param format - The format string to use. Only `"Month DD, YYYY, at HH:MM period"` and `"Month DD"` are supported.
- *
- * @param options - Optional settings.
- *
- * @param options.utc - If `true`, format the date in UTC instead of local time. Defaults to `false`.
- *
- * @returns The formatted date string.
- */
-export default function formatDate(date: Date, format: "Month DD, YYYY, at HH:MM period" | "Month DD", options?: {
-    utc?: boolean;
-}): string;
-//# sourceMappingURL=formatDate.d.ts.map

package/esm/helpers/formatDate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"formatDate.d.ts","sourceRoot":"","sources":["../../src/helpers/formatDate.ts"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,CAAC,OAAO,UAAU,UAAU,CAChC,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,iCAAiC,GAAG,UAAU,EACtD,OAAO,GAAE;IAAE,GAAG,CAAC,EAAE,OAAO,CAAA;CAAO,GAC9B,MAAM,CA2BR"}

package/esm/helpers/formatDate.js

@@ -1,75 +0,0 @@
-const MONTHS = [
-    "January",
-    "February",
-    "March",
-    "April",
-    "May",
-    "June",
-    "July",
-    "August",
-    "September",
-    "October",
-    "November",
-    "December",
-];
-/**
- * Formats a `Date` object into a human-readable string using only the format
- * strings actually used in the project.
- *
- * @example
- * ```ts
- * // Format a date with time (local time).
- * const date = new Date("2023-01-01T01:35:00");
- * const formatted = formatDate(date, "Month DD, YYYY, at HH:MM period");
- * console.log(formatted); // "January 1, 2023, at 1:35 a.m."
- * ```
- *
- * @example
- * ```ts
- * // Format a date as month and day only (UTC).
- * const formatted = formatDate(new Date("2023-01-01"), "Month DD", { utc: true });
- * console.log(formatted); // "January 1"
- * ```
- *
- * @example
- * ```ts
- * // Minutes of ":00" are omitted.
- * const formatted = formatDate(new Date("2023-01-01T01:00:00"), "Month DD, YYYY, at HH:MM period", { utc: true });
- * console.log(formatted); // "January 1, 2023, at 1 a.m."
- * ```
- *
- * @param date - The `Date` object to format.
- *
- * @param format - The format string to use. Only `"Month DD, YYYY, at HH:MM period"` and `"Month DD"` are supported.
- *
- * @param options - Optional settings.
- *
- * @param options.utc - If `true`, format the date in UTC instead of local time. Defaults to `false`.
- *
- * @returns The formatted date string.
- */
-export default function formatDate(date, format, options = {}) {
-    const getFullYear = options.utc ? date.getUTCFullYear : date.getFullYear;
-    const getMonth = options.utc ? date.getUTCMonth : date.getMonth;
-    const getDate = options.utc ? date.getUTCDate : date.getDate;
-    const getHours = options.utc ? date.getUTCHours : date.getHours;
-    const getMinutes = options.utc ? date.getUTCMinutes : date.getMinutes;
-    const year = getFullYear.call(date);
-    const month = MONTHS[getMonth.call(date)];
-    const day = getDate.call(date);
-    const hours = getHours.call(date);
-    const minutes = getMinutes.call(date);
-    const period = hours >= 12 ? "p.m." : "a.m.";
-    const displayHours = hours % 12 || 12;
-    const displayMinutes = minutes.toString().padStart(2, "0");
-    if (format === "Month DD, YYYY, at HH:MM period") {
-        const time = minutes === 0
-            ? `${displayHours} ${period}`
-            : `${displayHours}:${displayMinutes} ${period}`;
-        return `${month} ${day}, ${year}, at ${time}`;
-    }
-    else if (format === "Month DD") {
-        return `${month} ${day}`;
-    }
-    return "";
-}