@cellaware/utils 8.11.19 → 8.11.20

package/dist/util.js

@@ -0,0 +1,288 @@
+// Miscellaneous  --------------------------------------------------------------------------
+export async function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+export function reverse(str) {
+    return str.split('').reverse().join('');
+}
+export function base64Encode(str) {
+    return Buffer.from(str, 'utf-8').toString('base64');
+}
+export function base64Decode(str) {
+    return Buffer.from(str, 'base64').toString('utf-8');
+}
+export function isArrayLike(obj) {
+    return (Array.isArray(obj) ||
+        (!!obj &&
+            obj.hasOwnProperty("length") &&
+            typeof obj.length === "number"));
+}
+/**
+ * Default `idx` is 100.
+ */
+export function truncateValue(value, idx) {
+    if (!value || typeof value !== 'string') {
+        return value;
+    }
+    let truncValue = truncateValuePreserveNewLines(value, idx);
+    if (truncValue.includes('\n')) {
+        truncValue = value.slice(0, truncValue.indexOf('\n')) + '...';
+    }
+    return truncValue;
+}
+/**
+ * Default `idx` is 100.
+ */
+export function truncateValuePreserveNewLines(value, idx) {
+    idx = idx ?? 100;
+    let truncValue = value.length > idx ? value.slice(0, idx) + '...' : value;
+    return truncValue;
+}
+// Dates  --------------------------------------------------------------------------
+export function initDate(timeZone) {
+    const date = new Date();
+    if (!!timeZone) {
+        return new Date(date.toLocaleString('en-US', { timeZone }));
+    }
+    else {
+        return date;
+    }
+}
+export function convertDateTimeZone(date, timeZone) {
+    if (!!timeZone) {
+        return new Date(date.toLocaleString('en-US', { timeZone }));
+    }
+    else {
+        return date;
+    }
+}
+export function isDaylightSavingTime(timeZone) {
+    const date = initDate(timeZone);
+    const jan = new Date(date.getFullYear(), 0, 1);
+    const jul = new Date(date.getFullYear(), 6, 1);
+    return date.getTimezoneOffset() < Math.max(jan.getTimezoneOffset(), jul.getTimezoneOffset());
+}
+export function isLeapYear(timeZone) {
+    let year = initDate(timeZone).getFullYear();
+    return ((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0);
+}
+export function getDaysInMonth(timeZone) {
+    let date = initDate(timeZone);
+    // NOTE: month is 0-based.
+    return new Date(date.getFullYear(), date.getMonth() + 1, 0).getDate();
+}
+export function getCurrentDayInMonth(timeZone) {
+    let date = initDate(timeZone);
+    return date.getDate();
+}
+export function getDaysInYear(timeZone) {
+    return isLeapYear(timeZone) ? 366 : 365;
+}
+export function getCurrentMonth(timeZone) {
+    let date = initDate(timeZone);
+    // NOTE: month is 0-based.
+    return date.getMonth() + 1;
+}
+export function getCurrentYear(timeZone) {
+    let date = initDate(timeZone);
+    return date.getFullYear();
+}
+export function isDateString(value) {
+    if (typeof value !== 'string')
+        return false;
+    const str = value.trim();
+    /* To be considered a date string, the string:
+        - Must contain at least one digit
+        - Must include a common date separator (e.g. '-', '/', ':', '.', or 'T')
+        - Must not contain any letters other than 'T' or 'Z'
+        - Must successfully parse
+    
+       NOTE: We are not worried about month/day names or AM/PM. If these exist,
+       the user has clearly elected to format the date in the query itself. */
+    if (/[^TZ0-9\s:./-]/i.test(str))
+        return false;
+    /* Handle some edge cases:
+        - If 2 separators, should be at least 6 total characters
+        - Every part separated by '-' or '/' must be 1, 2, or >=4 chars long */
+    if (str.includes('-')) {
+        const dashes = str.split('-');
+        if (dashes.length > 1 && str.length < 6) {
+            return false;
+        }
+    }
+    else if (str.includes('/')) {
+        const slashes = str.split('/');
+        if (slashes.length > 1 && str.length < 6) {
+            return false;
+        }
+    }
+    const sections = str.split(/[-/]+/).filter(Boolean);
+    if (sections.some(s => !(s.length === 1 || s.length === 2 || s.length >= 4))) {
+        return false;
+    }
+    return !isNaN(Date.parse(str));
+}
+/**
+ * Will only return matches that **are not** contained in single quotes,
+ * double quotes, single line, or multiline comments.
+ */
+export function getQueryMatches(query, regex, specificMatchGroup) {
+    let matches = [];
+    // Find quote ranges first.
+    let singleQuoteRanges = [];
+    {
+        let open = false;
+        let startIdx = -1;
+        for (let i = 0; i < query.length; i++) {
+            if (query[i] === "'") {
+                if (open) {
+                    singleQuoteRanges.push({ startIdx, stopIdx: i });
+                }
+                else {
+                    startIdx = i;
+                }
+                open = !open;
+            }
+        }
+    }
+    let doubleQuoteRanges = [];
+    {
+        let open = false;
+        let startIdx = -1;
+        for (let i = 0; i < query.length; i++) {
+            if (query[i] === '"') {
+                if (open) {
+                    doubleQuoteRanges.push({ startIdx, stopIdx: i });
+                }
+                else {
+                    startIdx = i;
+                }
+                open = !open;
+            }
+        }
+    }
+    let singleLineCommentRanges = [];
+    {
+        let open = false;
+        let startIdx = -1;
+        for (let i = 0; i < query.length; i++) {
+            if (!open && query[i] === '-' && (i < query.length - 1 && query[i + 1] === '-')) {
+                open = true;
+                startIdx = i;
+            }
+            else if (open && (query[i] === '\n' || query[i] === '\r')) {
+                open = false;
+                singleLineCommentRanges.push({ startIdx, stopIdx: i });
+            }
+        }
+    }
+    let multilineCommentRanges = [];
+    {
+        let open = false;
+        let startIdx = -1;
+        for (let i = 0; i < query.length; i++) {
+            if (!open && query[i] === '/' && (i < query.length - 1 && query[i + 1] === '*')) {
+                open = true;
+                startIdx = i;
+            }
+            else if (open && query[i] === '/' && (i > 0 && query[i - 1] === '*')) {
+                open = false;
+                multilineCommentRanges.push({ startIdx, stopIdx: i });
+            }
+        }
+    }
+    // Now find matches and filter out the ones that are contained in quotes.
+    {
+        let match;
+        while ((match = regex.exec(query)) != null) {
+            let startIdx = match.index;
+            let stopIdx = match.index + match[0].length - 1;
+            let contained = false;
+            for (const quoteRange of singleQuoteRanges) {
+                if (quoteRange.startIdx <= startIdx && quoteRange.stopIdx >= stopIdx) {
+                    contained = true;
+                    break;
+                }
+            }
+            if (!contained) {
+                for (const quoteRange of doubleQuoteRanges) {
+                    if (quoteRange.startIdx <= startIdx && quoteRange.stopIdx >= stopIdx) {
+                        contained = true;
+                        break;
+                    }
+                }
+            }
+            if (!contained) {
+                for (const singleLineCommentRange of singleLineCommentRanges) {
+                    if (singleLineCommentRange.startIdx <= startIdx && singleLineCommentRange.stopIdx >= stopIdx) {
+                        contained = true;
+                        break;
+                    }
+                }
+            }
+            if (!contained) {
+                for (const multilineCommentRange of multilineCommentRanges) {
+                    if (multilineCommentRange.startIdx <= startIdx && multilineCommentRange.stopIdx >= stopIdx) {
+                        contained = true;
+                        break;
+                    }
+                }
+            }
+            if (!contained) {
+                matches.push({ word: match[specificMatchGroup ?? 0], startIdx, stopIdx });
+            }
+        }
+    }
+    return matches;
+}
+export function removeQueryMatches(query, matches) {
+    let adjQuery = query;
+    let offset = 0;
+    for (const match of matches) {
+        const start = match.startIdx - offset;
+        const stop = match.stopIdx + 1 - offset;
+        adjQuery = adjQuery.substring(0, start) + adjQuery.substring(stop);
+        offset += match.word.length;
+    }
+    return adjQuery;
+}
+export function replaceQueryMatches(query, matches, replacement, useMatchAsSuffix) {
+    let adjQuery = query;
+    let offset = 0;
+    for (const match of matches) {
+        const start = match.startIdx - offset;
+        const stop = match.stopIdx + 1 - offset;
+        let adjReplacement = replacement;
+        if (!!useMatchAsSuffix) {
+            adjReplacement = replacement + '_' + match.word;
+        }
+        adjQuery =
+            adjQuery.substring(0, start) +
+                adjReplacement +
+                adjQuery.substring(stop);
+        offset += (match.word.length - adjReplacement.length);
+    }
+    return adjQuery;
+}
+// LLMs --------------------------------------------------------------------------
+export function removeMarkdownIndicators(input) {
+    let output = input;
+    // Make sure markdown indicator exists.
+    if (output.includes('```')) {
+        // Remove first markdown indicator.
+        output = output.substring(output.indexOf('```'));
+        output = output.substring(output.indexOf('\n'));
+        // First markdown indicator removed, now do the last.
+        output = output.substring(0, output.indexOf('```')).trim();
+    }
+    return output;
+}
+export function removePrefixIndicators(input, prefixes) {
+    let output = input;
+    for (const prefix of prefixes) {
+        if (output.includes(prefix)) {
+            output = output.substring(output.indexOf(prefix) + prefix.length);
+        }
+    }
+    return output;
+}

package/dist/version.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Extracts `version` from `package.json`.
+ */
+export declare function getVersion(): string;

package/dist/version.js

@@ -0,0 +1,12 @@
+import fs from 'fs';
+/**
+ * Extracts `version` from `package.json`.
+ */
+export function getVersion() {
+    const path = 'package.json';
+    if (!fs.existsSync(path)) {
+        throw new Error(`VERSION: '${path}' not found`);
+    }
+    const content = JSON.parse(fs.readFileSync(path, 'utf8'));
+    return content.version ?? '';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cellaware/utils",
-    "version": "8.11.19",
+    "version": "8.11.20",
     "description": "Cellaware Utilities for Node.js",
     "author": "Cellaware Technologies",
     "type": "module",