df-script 1.4.0

package/dist/utils/date.js

@@ -0,0 +1,349 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STRFTIME_DIRECTIVES = exports.NS_PER_MS = exports.US_PER_MS = exports.MS_PER_DAY = exports.MS_PER_HOUR = exports.MS_PER_MINUTE = exports.MS_PER_SECOND = exports.UTC_INDICATOR_REGEX = exports.ZONE_OFFSET_REGEX = exports.TIME_PREFIX_REGEX = void 0;
+exports.toEpoch = toEpoch;
+exports.getCentury = getCentury;
+exports.getISOWeek = getISOWeek;
+exports.getMillennium = getMillennium;
+exports.getMonthOffset = getMonthOffset;
+exports.getOrdinalDay = getOrdinalDay;
+exports.getQuarter = getQuarter;
+exports.getUtcOffset = getUtcOffset;
+exports.isLeapYear = isLeapYear;
+exports.isUtcString = isUtcString;
+exports.isValidDate = isValidDate;
+exports.isValidDateObj = isValidDateObj;
+exports.normalizeEpochToMs = normalizeEpochToMs;
+exports.strftime = strftime;
+exports.strptime = strptime;
+exports.toValidDate = toValidDate;
+const number_1 = require("./number");
+/**
+ * Matches string values beginning with standard hour-and-minute formatting.
+ * Examples:
+ * - "12:34" (matches "12:34")
+ * - "10:37:16.123" (matches "10:37")
+ * - "2026-05-25" (does not match)
+ */
+exports.TIME_PREFIX_REGEX = /^\d{2}:\d{2}/;
+/**
+ * Matches timezone offset indicators at the end of a string.
+ * Examples:
+ * - "12:34:56Z" (matches "Z")
+ * - "12:34:56+02:00" (matches "+02:00")
+ * - "12:34:56-0500" (matches "-0500")
+ * - "12:34:56-05" (matches "-05")
+ * - "12:34:56" (does not match)
+ */
+exports.ZONE_OFFSET_REGEX = /(?:Z|[+-]\d{2}(?::?\d{2})?)$/i;
+/**
+ * Matches only UTC offset indicators at the end of a string.
+ * Examples:
+ * - "12:34:56Z" (matches "Z")
+ * - "12:34:56+00:00" (matches "+00:00")
+ * - "12:34:56-0000" (matches "-0000")
+ * - "12:34:56+02:00" (does not match)
+ */
+exports.UTC_INDICATOR_REGEX = /(?:Z|[+-]00:00|[+-]0000|[+-]00)$/i;
+exports.MS_PER_SECOND = 1000;
+exports.MS_PER_MINUTE = 60_000;
+exports.MS_PER_HOUR = 3_600_000;
+exports.MS_PER_DAY = 86_400_000;
+exports.US_PER_MS = 1000;
+exports.NS_PER_MS = 1_000_000;
+function toEpoch(d, unit = "ms") {
+    const ms = d.getTime();
+    switch (unit) {
+        case "s": return Math.floor(ms / exports.MS_PER_SECOND);
+        case "ms": return ms;
+        case "us": return ms * exports.US_PER_MS;
+        case "ns": return ms * exports.NS_PER_MS;
+    }
+}
+function getCentury(d) {
+    const y = d.getUTCFullYear();
+    return Math.floor((y - 1) / 100) + 1;
+}
+function getISOWeek(d) {
+    const date = new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate()));
+    const dayNum = date.getUTCDay() || 7;
+    date.setUTCDate(date.getUTCDate() + 4 - dayNum);
+    const yearStart = new Date(Date.UTC(date.getUTCFullYear(), 0, 1));
+    return Math.ceil((((date.getTime() - yearStart.getTime()) / exports.MS_PER_DAY) + 1) / 7);
+}
+function getMillennium(d) {
+    const y = d.getUTCFullYear();
+    return Math.floor((y - 1) / 1000) + 1;
+}
+function getMonthOffset(d, monthOffset, day = 1) {
+    return new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth() + monthOffset, day, 0, 0, 0, 0));
+}
+function getOrdinalDay(d) {
+    const start = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+    const diff = d.getTime() - start.getTime();
+    return Math.floor(diff / exports.MS_PER_DAY) + 1;
+}
+function getQuarter(d) {
+    return Math.floor(d.getUTCMonth() / 3) + 1;
+}
+function getUtcOffset(timeZone) {
+    const now = new Date();
+    const utcMs = now.getTime() + now.getTimezoneOffset() * 60_000;
+    const tzTime = new Date(now.toLocaleString('en-US', { timeZone }));
+    const tzMs = tzTime.getTime();
+    const offsetMin = Math.round((tzMs - utcMs) / 60_000);
+    const sign = offsetMin >= 0 ? "+" : "\u2212";
+    const h = Math.floor(Math.abs(offsetMin) / 60);
+    const m = Math.abs(offsetMin) % 60;
+    const formatted = `UTC${sign}${String(h).padStart(2, "0")}:${String(m).padStart(2, "0")}`;
+    return {
+        timeZoneTime: tzTime,
+        utcTime: now,
+        offset: offsetMin,
+        formatted
+    };
+}
+function isLeapYear(yOrDate) {
+    const y = yOrDate instanceof Date ? yOrDate.getUTCFullYear() : yOrDate;
+    return (y % 4 === 0 && y % 100 !== 0) || y % 400 === 0;
+}
+function isUtcString(timestamp) {
+    if (!timestamp)
+        return false;
+    const trimmed = timestamp.trim();
+    if (!trimmed)
+        return false;
+    return exports.UTC_INDICATOR_REGEX.test(trimmed);
+}
+function isValidDate(v) {
+    if (v == null)
+        return false;
+    if (v instanceof Date)
+        return isValidDateObj(v);
+    if (typeof v === "number") {
+        if (!(0, number_1.isValidNumber)(v))
+            return false;
+        return isValidDateObj(new Date(normalizeEpochToMs(v)));
+    }
+    if (typeof v === "bigint") {
+        return isValidDateObj(new Date(normalizeEpochToMs(Number(v))));
+    }
+    if (typeof v === "string") {
+        const s = v.trim();
+        if (s === "")
+            return false;
+        return isValidDateObj(new Date(s));
+    }
+    return false;
+}
+function isValidDateObj(d) {
+    return d instanceof Date && !Number.isNaN(d.getTime());
+}
+function normalizeEpochToMs(n) {
+    const abs = Math.abs(n);
+    if (abs >= 1e12)
+        return n;
+    if (abs <= 1e10)
+        return n * 1000;
+    return n;
+}
+exports.STRFTIME_DIRECTIVES = [
+    "%ms", "%f", "%Y", "%y", "%m", "%d", "%e", "%H", "%I", "%p", "%M", "%S", "%A", "%a", "%B", "%b", "%h", "%j", "%u", "%w", "%Z", "%z"
+];
+function strftime(d, format, locale) {
+    let result = format;
+    // 1. Literal %% escaping
+    result = result.replace(/%%/g, "\0");
+    // 2. High-level shorthand formats
+    result = result.replace(/%F/g, "%Y-%m-%d");
+    result = result.replace(/%T/g, "%H:%M:%S");
+    result = result.replace(/%R/g, "%H:%M");
+    result = result.replace(/%D/g, "%m/%d/%y");
+    // 3. Directives replacements with lazy getters
+    const replacements = {
+        get "%Y"() { return String(d.getUTCFullYear()); },
+        get "%y"() { return String(d.getUTCFullYear() % 100).padStart(2, "0"); },
+        get "%m"() { return String(d.getUTCMonth() + 1).padStart(2, "0"); },
+        get "%d"() { return String(d.getUTCDate()).padStart(2, "0"); },
+        get "%e"() { return String(d.getUTCDate()).padStart(2, " "); },
+        get "%H"() { return String(d.getUTCHours()).padStart(2, "0"); },
+        get "%I"() { return String(d.getUTCHours() % 12 || 12).padStart(2, "0"); },
+        get "%p"() { return d.getUTCHours() >= 12 ? "PM" : "AM"; },
+        get "%M"() { return String(d.getUTCMinutes()).padStart(2, "0"); },
+        get "%S"() { return String(d.getUTCSeconds()).padStart(2, "0"); },
+        get "%A"() { return d.toLocaleDateString(locale, { weekday: "long", timeZone: "UTC" }); },
+        get "%a"() { return d.toLocaleDateString(locale, { weekday: "short", timeZone: "UTC" }); },
+        get "%B"() { return d.toLocaleDateString(locale, { month: "long", timeZone: "UTC" }); },
+        get "%b"() { return d.toLocaleDateString(locale, { month: "short", timeZone: "UTC" }); },
+        get "%h"() { return d.toLocaleDateString(locale, { month: "short", timeZone: "UTC" }); },
+        get "%j"() {
+            const start = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+            const diff = d.getTime() - start.getTime();
+            const dayOfYear = Math.floor(diff / exports.MS_PER_DAY) + 1;
+            return String(dayOfYear).padStart(3, "0");
+        },
+        get "%u"() { return String(d.getUTCDay() || 7); },
+        get "%w"() { return String(d.getUTCDay()); },
+        get "%Z"() { return "UTC"; },
+        get "%z"() { return "+0000"; },
+        get "%ms"() { return String(d.getUTCMilliseconds()).padStart(3, "0"); },
+        get "%f"() { return String(d.getUTCMilliseconds() * 1000).padStart(6, "0"); }
+    };
+    for (const directive of exports.STRFTIME_DIRECTIVES) {
+        if (result.includes(directive)) {
+            result = result.replaceAll(directive, replacements[directive]);
+        }
+    }
+    // 4. Restore literal percent symbols
+    return result.replace(/\0/g, "%");
+}
+function strptime(str, format, strict = true) {
+    if (typeof str !== "string" || typeof format !== "string")
+        return null;
+    const placeholders = [];
+    let groupIndex = 1;
+    let regexStr = "";
+    let i = 0;
+    while (i < format.length) {
+        const char = format[i];
+        if (char === "%") {
+            if (i + 1 < format.length) {
+                const nextChar = format[i + 1];
+                if (nextChar === "%") {
+                    regexStr += "%";
+                    i += 2;
+                }
+                else if (format.slice(i, i + 3) === "%ms") {
+                    placeholders.push({ name: "ms", index: groupIndex++ });
+                    regexStr += "(\\d{1,3})";
+                    i += 3;
+                }
+                else {
+                    switch (nextChar) {
+                        case "Y":
+                            placeholders.push({ name: "year", index: groupIndex++ });
+                            regexStr += "(\\d{4})";
+                            break;
+                        case "y":
+                            placeholders.push({ name: "year_short", index: groupIndex++ });
+                            regexStr += "(\\d{2})";
+                            break;
+                        case "m":
+                            placeholders.push({ name: "month", index: groupIndex++ });
+                            regexStr += "(\\d{1,2})";
+                            break;
+                        case "d":
+                        case "e":
+                            placeholders.push({ name: "day", index: groupIndex++ });
+                            regexStr += "(\\d{1,2})";
+                            break;
+                        case "H":
+                        case "I":
+                            placeholders.push({ name: "hour", index: groupIndex++ });
+                            regexStr += "(\\d{1,2})";
+                            break;
+                        case "M":
+                            placeholders.push({ name: "minute", index: groupIndex++ });
+                            regexStr += "(\\d{1,2})";
+                            break;
+                        case "S":
+                            placeholders.push({ name: "second", index: groupIndex++ });
+                            regexStr += "(\\d{1,2})";
+                            break;
+                        case "f":
+                            placeholders.push({ name: "fractional", index: groupIndex++ });
+                            regexStr += "(\\d{1,6})";
+                            break;
+                        default:
+                            regexStr += char + nextChar;
+                    }
+                    i += 2;
+                }
+            }
+            else {
+                regexStr += char;
+                i++;
+            }
+        }
+        else {
+            if ("\\^$*+?.()|[]{}".indexOf(char) !== -1) {
+                regexStr += "\\" + char;
+            }
+            else {
+                regexStr += char;
+            }
+            i++;
+        }
+    }
+    const regex = new RegExp("^" + regexStr + "$");
+    const match = str.match(regex);
+    if (!match) {
+        if (strict)
+            return null;
+        const parsed = new Date(str);
+        return isValidDateObj(parsed) ? parsed : null;
+    }
+    let year = 1970;
+    let month = 1;
+    let day = 1;
+    let hour = 0;
+    let minute = 0;
+    let second = 0;
+    let ms = 0;
+    for (const p of placeholders) {
+        const valStr = match[p.index];
+        const val = parseInt(valStr, 10);
+        switch (p.name) {
+            case "year":
+                year = val;
+                break;
+            case "year_short":
+                year = val + (val >= 69 ? 1900 : 2000);
+                break;
+            case "month":
+                month = val;
+                break;
+            case "day":
+                day = val;
+                break;
+            case "hour":
+                hour = val;
+                break;
+            case "minute":
+                minute = val;
+                break;
+            case "second":
+                second = val;
+                break;
+            case "ms":
+                ms = parseInt(valStr.padEnd(3, "0").slice(0, 3), 10);
+                break;
+            case "fractional":
+                ms = parseInt(valStr.padEnd(6, "0").slice(0, 3), 10);
+                break;
+        }
+    }
+    const d = new Date(Date.UTC(year, month - 1, day, hour, minute, second, ms));
+    return isValidDateObj(d) ? d : null;
+}
+function toValidDate(input) {
+    if (input instanceof Date) {
+        return isValidDateObj(input) ? input : null;
+    }
+    if (typeof input === "number") {
+        const d = new Date(normalizeEpochToMs(input));
+        return isValidDateObj(d) ? d : null;
+    }
+    if (typeof input === "bigint") {
+        const d = new Date(normalizeEpochToMs(Number(input)));
+        return isValidDateObj(d) ? d : null;
+    }
+    if (typeof input === "string") {
+        const s = input.trim();
+        if (s === "")
+            return null;
+        const d = new Date(s);
+        return isValidDateObj(d) ? d : null;
+    }
+    return null;
+}

package/dist/utils/guards.d.ts

@@ -0,0 +1,14 @@
+export declare function isTypedArray(v: unknown): v is ArrayBufferView;
+export declare function isArrayOrTypedArray(v: unknown): v is ArrayLike<any> & Iterable<any>;
+export declare function isNonEmptyArray<T = unknown>(arr: unknown): arr is ArrayLike<T>;
+export declare function isNonEmptyArrayObjs<T extends object>(arr: unknown): arr is T[];
+export declare function isNonEmptyObj(v: unknown): v is Record<string, unknown>;
+export declare function isObj(v: unknown): v is Record<string, unknown>;
+export declare function isPlainObj(v: unknown): v is Record<string, unknown>;
+export declare function isClass(v: unknown): v is new (...args: any[]) => any;
+export declare function isScalar(v: unknown): v is string | number | boolean | bigint | Date | Uint8Array;
+export declare function isValidBinary(v: unknown): v is Uint8Array | string | ArrayLike<any>;
+export declare function toValidBinary(v: unknown): Uint8Array | null;
+export declare function tryParseBoolean(v: unknown): boolean | undefined;
+export declare function isJsonString(input: unknown, allowPrimitives?: boolean): input is string;
+export declare function safeJsonParse(input: unknown): unknown;

package/dist/utils/guards.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTypedArray = isTypedArray;
+exports.isArrayOrTypedArray = isArrayOrTypedArray;
+exports.isNonEmptyArray = isNonEmptyArray;
+exports.isNonEmptyArrayObjs = isNonEmptyArrayObjs;
+exports.isNonEmptyObj = isNonEmptyObj;
+exports.isObj = isObj;
+exports.isPlainObj = isPlainObj;
+exports.isClass = isClass;
+exports.isScalar = isScalar;
+exports.isValidBinary = isValidBinary;
+exports.toValidBinary = toValidBinary;
+exports.tryParseBoolean = tryParseBoolean;
+exports.isJsonString = isJsonString;
+exports.safeJsonParse = safeJsonParse;
+const date_1 = require("./date");
+const number_1 = require("./number");
+function isTypedArray(v) {
+    return ArrayBuffer.isView(v) && !(v instanceof DataView);
+}
+function isArrayOrTypedArray(v) {
+    return Array.isArray(v) || isTypedArray(v);
+}
+function isNonEmptyArray(arr) {
+    return isArrayOrTypedArray(arr) && arr.length > 0;
+}
+function isNonEmptyArrayObjs(arr) {
+    if (!isNonEmptyArray(arr))
+        return false;
+    const len = arr.length;
+    for (let i = 0; i < len; i++) {
+        if (!isObj(arr[i]))
+            return false;
+    }
+    return true;
+}
+function isNonEmptyObj(v) {
+    return isObj(v) && Object.keys(v).length > 0;
+}
+function isObj(v) {
+    return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+function isPlainObj(v) {
+    if (!isObj(v))
+        return false;
+    const proto = Object.getPrototypeOf(v);
+    return proto === null || proto === Object.prototype;
+}
+function isClass(v) {
+    if (typeof v !== "function")
+        return false;
+    return (/^class\s/.test(Function.prototype.toString.call(v)) ||
+        (v.prototype !== undefined &&
+            v.prototype.constructor === v &&
+            Object.getOwnPropertyDescriptor(v, "prototype")?.writable === false));
+}
+function isScalar(v) {
+    return (typeof v === "string" ||
+        typeof v === "number" ||
+        typeof v === "boolean" ||
+        typeof v === "bigint" ||
+        (0, date_1.isValidDateObj)(v) ||
+        v instanceof Uint8Array);
+}
+function isValidBinary(v) {
+    if (v == null)
+        return false;
+    if (v instanceof Uint8Array)
+        return true;
+    if (typeof v === "string")
+        return true;
+    if (Array.isArray(v)) {
+        const len = v.length;
+        for (let i = 0; i < len; i++) {
+            if (!(0, number_1.isValidInt)(v[i], { min: -128, max: 255 })) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (isTypedArray(v)) {
+        return true;
+    }
+    return false;
+}
+function toValidBinary(v) {
+    if (!isValidBinary(v))
+        return null;
+    if (v instanceof Uint8Array)
+        return v;
+    if (typeof v === "string") {
+        return new TextEncoder().encode(v);
+    }
+    if (ArrayBuffer.isView(v)) {
+        return new Uint8Array(v.buffer, v.byteOffset, v.byteLength);
+    }
+    return new Uint8Array(v);
+}
+const boolMap = {
+    true: true, "1": true, yes: true, y: true, on: true,
+    false: false, "0": false, no: false, n: false, off: false
+};
+function tryParseBoolean(v) {
+    if (typeof v === "boolean")
+        return v;
+    if (v === 1)
+        return true;
+    if (v === 0)
+        return false;
+    if (typeof v !== "string")
+        return undefined;
+    return boolMap[v.trim().toLowerCase()];
+}
+function isJsonString(input, allowPrimitives = false) {
+    if (typeof input !== "string")
+        return false;
+    const s = input.trim();
+    if (s === "")
+        return false;
+    if (!allowPrimitives) {
+        const isWrapped = (s.startsWith("{") && s.endsWith("}")) || (s.startsWith("[") && s.endsWith("]"));
+        if (!isWrapped)
+            return false;
+    }
+    try {
+        JSON.parse(s);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function safeJsonParse(input) {
+    if (typeof input !== "string")
+        return input;
+    try {
+        return JSON.parse(input);
+    }
+    catch {
+        return input;
+    }
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./guards";
+export * from "./number";
+export * from "./date";
+export * from "./list";
+export * from "./string";

package/dist/utils/index.js

@@ -0,0 +1,21 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./guards"), exports);
+__exportStar(require("./number"), exports);
+__exportStar(require("./date"), exports);
+__exportStar(require("./list"), exports);
+__exportStar(require("./string"), exports);

package/dist/utils/json.d.ts

@@ -0,0 +1,2 @@
+export declare function isJsonString(input: unknown, allowPrimitives?: boolean): input is string;
+export declare function safeJsonParse(input: unknown): unknown;

package/dist/utils/json.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isJsonString = isJsonString;
+exports.safeJsonParse = safeJsonParse;
+function isJsonString(input, allowPrimitives = false) {
+    if (typeof input !== "string")
+        return false;
+    const s = input.trim();
+    if (s === "")
+        return false;
+    if (!allowPrimitives) {
+        const isWrapped = (s.startsWith("{") && s.endsWith("}")) || (s.startsWith("[") && s.endsWith("]"));
+        if (!isWrapped)
+            return false;
+    }
+    try {
+        JSON.parse(s);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function safeJsonParse(input) {
+    if (typeof input !== "string")
+        return input;
+    try {
+        return JSON.parse(input);
+    }
+    catch {
+        return input;
+    }
+}

package/dist/utils/list.d.ts

@@ -0,0 +1,23 @@
+export type ArrayItemType = "string" | "number" | "boolean" | "bigint" | "object" | "plainObject" | "date" | (new (...args: any[]) => any) | ((v: unknown) => boolean);
+export type ArrayCheckMode = "every" | "some";
+export type IsArrayOfTypeOptionsParams = {
+    mode?: ArrayCheckMode;
+    allowNulls?: boolean;
+    allowEmpty?: boolean;
+};
+export declare function toValidArray<T>(val: T | T[] | null | undefined): T[];
+export declare function isArrayOfType(arr: unknown, type: ArrayItemType, { mode, allowNulls, allowEmpty }?: IsArrayOfTypeOptionsParams): boolean;
+export declare function sortList(arr: unknown, descending?: boolean): any[];
+export declare function getListStats(arr: unknown): {
+    sum: number | null;
+    count: number;
+    min: any;
+    max: any;
+    mean: number | null;
+    variance: number;
+    std: number;
+    nullCount: number;
+    len: number;
+    hasNulls: boolean;
+    isNumeric: boolean;
+};