@pogodisco/ts-kit 0.0.1

package/dist/accessors/get-at-path.d.ts

@@ -0,0 +1 @@
+export declare function getAtPath(obj: any, path: string): any;

package/dist/accessors/get-at-path.js

@@ -0,0 +1,13 @@
+export function getAtPath(obj, path) {
+    const keys = path.split(".");
+    return keys.reduce((acc, key) => {
+        if (!acc)
+            return undefined;
+        const match = key.match(/^(\w+)\[(\d+)\]$/);
+        if (match) {
+            const [, arrKey, index] = match;
+            return acc[arrKey]?.[Number(index)];
+        }
+        return acc[key];
+    }, obj);
+}

package/dist/accessors/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./push-to-nested-array.js";
+export * from "./set-deep-object-value.js";
+export * from "./push-unique-to-array.js";
+export * from "./get-at-path.js";
+export * from "./set-at-path.js";
+export * from "./select-map.js";

package/dist/accessors/index.js

@@ -0,0 +1,6 @@
+export * from "./push-to-nested-array.js";
+export * from "./set-deep-object-value.js";
+export * from "./push-unique-to-array.js";
+export * from "./get-at-path.js";
+export * from "./set-at-path.js";
+export * from "./select-map.js";

package/dist/accessors/push-to-nested-array.d.ts

@@ -0,0 +1 @@
+export declare function pushToNestedArray(obj: Record<string, any>, path: string, value: any): void;

package/dist/accessors/push-to-nested-array.js

@@ -0,0 +1,16 @@
+export function pushToNestedArray(obj, path, value) {
+    const keys = path.split(".");
+    let current = obj;
+    for (let i = 0; i < keys.length - 1; i++) {
+        const key = keys[i];
+        if (!(key in current) || typeof current[key] !== "object") {
+            current[key] = {};
+        }
+        current = current[key];
+    }
+    const finalKey = keys[keys.length - 1];
+    if (!Array.isArray(current[finalKey])) {
+        current[finalKey] = [];
+    }
+    current[finalKey].push(value);
+}

package/dist/accessors/push-unique-to-array.d.ts

@@ -0,0 +1 @@
+export declare const pushUniqueToArray: (target: any[], value: any) => void;

package/dist/accessors/push-unique-to-array.js

@@ -0,0 +1,5 @@
+export const pushUniqueToArray = (target, value) => {
+    if (!target.includes(value)) {
+        target.push(value);
+    }
+};

package/dist/accessors/select-map.d.ts

@@ -0,0 +1 @@
+export declare function selectMap(map: Record<string, string>): (key: string) => string | undefined;

package/dist/accessors/select-map.js

@@ -0,0 +1,5 @@
+export function selectMap(map) {
+    return (key) => {
+        return map[key];
+    };
+}

package/dist/accessors/set-at-path.d.ts

@@ -0,0 +1 @@
+export declare function setAtPath(obj: any, path: string, value: any): void;

package/dist/accessors/set-at-path.js

@@ -0,0 +1,30 @@
+export function setAtPath(obj, path, value) {
+    const keys = path.split(".");
+    const lastKey = keys.pop();
+    const target = keys.reduce((acc, key) => {
+        const match = key.match(/^(\w+)\[(\d+)\]$/);
+        if (match) {
+            const [, arrKey, index] = match;
+            if (!acc[arrKey])
+                acc[arrKey] = [];
+            if (!acc[arrKey][Number(index)])
+                acc[arrKey][Number(index)] = {};
+            return acc[arrKey][Number(index)];
+        }
+        if (!acc[key])
+            acc[key] = {};
+        return acc[key];
+    }, obj);
+    if (!lastKey)
+        return;
+    const match = lastKey.match(/^(\w+)\[(\d+)\]$/);
+    if (match) {
+        const [, arrKey, index] = match;
+        if (!target[arrKey])
+            target[arrKey] = [];
+        target[arrKey][Number(index)] = value;
+    }
+    else {
+        target[lastKey] = value;
+    }
+}

package/dist/accessors/set-deep-object-value.d.ts

@@ -0,0 +1 @@
+export declare function setObjectValue(obj: Record<string, any>, path: string, value: any): void;

package/dist/accessors/set-deep-object-value.js

@@ -0,0 +1,12 @@
+export function setObjectValue(obj, path, value) {
+    const keys = path.split(".");
+    let current = obj;
+    for (let i = 0; i < keys.length - 1; i++) {
+        const key = keys[i];
+        if (!(key in current) || typeof current[key] !== "object") {
+            current[key] = {};
+        }
+        current = current[key];
+    }
+    current[keys[keys.length - 1]] = value;
+}

package/dist/array/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./random-from-array.js";
+export * from "./random-subset-from-array.js";

package/dist/array/index.js

@@ -0,0 +1,2 @@
+export * from "./random-from-array.js";
+export * from "./random-subset-from-array.js";

package/dist/array/random-from-array.d.ts

@@ -0,0 +1 @@
+export declare function randomFromArray<T>(arr: T[]): T | undefined;

package/dist/array/random-from-array.js

@@ -0,0 +1,6 @@
+export function randomFromArray(arr) {
+    if (!arr.length)
+        return undefined;
+    const index = Math.floor(Math.random() * arr.length);
+    return arr[index];
+}

package/dist/array/random-subset-from-array.d.ts

@@ -0,0 +1 @@
+export declare function randomSubsetFromArray<T>(arr: T[], min: number, max: number): T[];

package/dist/array/random-subset-from-array.js

@@ -0,0 +1,12 @@
+export function randomSubsetFromArray(arr, min, max) {
+    if (!arr.length || min > arr.length)
+        return [];
+    const size = Math.floor(Math.random() * (max - min + 1)) + min;
+    // shuffle a copy of the array (Fisher-Yates)
+    const copy = [...arr];
+    for (let i = copy.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [copy[i], copy[j]] = [copy[j], copy[i]];
+    }
+    return copy.slice(0, Math.min(size, copy.length));
+}

package/dist/data/file-content-types.d.ts

@@ -0,0 +1,8 @@
+export declare const imageTypes: string[];
+export declare const videoTypes: string[];
+export declare const audioTypes: string[];
+export declare const documentTypes: string[];
+export declare const compressedTypes: string[];
+export declare const dataTypes: string[];
+export declare const apiAndWebTypes: string[];
+export declare const contentTypes: string[];

package/dist/data/file-content-types.js

@@ -0,0 +1,61 @@
+export const imageTypes = [
+    "image/jpeg",
+    "image/png",
+    "image/gif",
+    "image/svg+xml",
+    "image/webp",
+    "image/avif",
+    "image/bmp",
+    "image/tiff",
+];
+export const videoTypes = [
+    "video/mp4",
+    "video/webm",
+    "video/ogg",
+    "video/x-msvideo",
+    "video/quicktime",
+];
+export const audioTypes = ["audio/mpeg", "audio/wav", "audi/ogg", "audio/flac"];
+export const documentTypes = [
+    "application/pdf",
+    "application/msword",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    "application/vnd.ms-excel",
+    "application/vnd.ms-powerpoint",
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    "text/plain",
+    "application/rtf",
+];
+export const compressedTypes = [
+    "application/zip",
+    "application/x-tar",
+    "application/x-rar-compressed",
+    "application/gzip",
+    "application/x-7z-compressed",
+];
+export const dataTypes = [
+    "application/json",
+    "application/xml",
+    "text/html",
+    "text/css",
+    "text/javascript",
+    "application/sql",
+    "application/x-sh",
+    "application/java-archive",
+    "application/octet-stream",
+];
+export const apiAndWebTypes = [
+    "application/x-www-form-urlencoded",
+    "multipart/form-data",
+    "application/x-ndjson",
+    "application/vnd.api+json",
+];
+export const contentTypes = [
+    ...imageTypes,
+    ...videoTypes,
+    ...audioTypes,
+    ...documentTypes,
+    ...compressedTypes,
+    ...dataTypes,
+    ...apiAndWebTypes,
+];

package/dist/data/index.d.ts

@@ -0,0 +1 @@
+export * from "./file-content-types.js";

package/dist/data/index.js

@@ -0,0 +1 @@
+export * from "./file-content-types.js";

package/dist/date/format-smart-date.d.ts

@@ -0,0 +1,8 @@
+import { Locale } from "date-fns";
+type SmartDateOpts = {
+    withTime?: boolean;
+    locale?: Locale;
+    referenceDate?: Date;
+};
+export declare function formatSmartDate(dateInput: string | Date, options?: SmartDateOpts): string;
+export {};

package/dist/date/format-smart-date.js

@@ -0,0 +1,32 @@
+import { format, isToday, isYesterday, isThisWeek, isThisYear, differenceInDays, parseISO, } from "date-fns";
+import { enUS } from "date-fns/locale";
+export function formatSmartDate(dateInput, options = {}) {
+    const { withTime = true, locale = enUS, referenceDate = new Date(), } = options;
+    if (!dateInput)
+        return "";
+    const date = typeof dateInput === "string" ? parseISO(dateInput) : new Date(dateInput);
+    const daysDiff = differenceInDays(referenceDate, date);
+    const timePart = withTime ? `, ${format(date, "HH:mm", { locale })}` : "";
+    // ✅ Today
+    if (isToday(date)) {
+        return format(date, withTime ? "HH:mm" : "d MMM", { locale });
+    }
+    // ✅ Yesterday
+    if (isYesterday(date)) {
+        return `Yesterday${timePart}`;
+    }
+    // ✅ This week
+    if (isThisWeek(date, { weekStartsOn: 1 })) {
+        return `${format(date, "EEE", { locale })}${timePart}`;
+    }
+    // ✅ Within last month
+    if (daysDiff <= 30) {
+        return `${format(date, "d MMM", { locale })}${timePart}`;
+    }
+    // ✅ Same year
+    if (isThisYear(date)) {
+        return `${format(date, "d MMM", { locale })}${timePart}`;
+    }
+    // ✅ Older
+    return `${format(date, "dd.MM.yyyy", { locale })}${timePart}`;
+}

package/dist/date/index.d.ts

@@ -0,0 +1 @@
+export * from "./format-smart-date.js";

package/dist/date/index.js

@@ -0,0 +1 @@
+export * from "./format-smart-date.js";

package/dist/finance/index.d.ts

@@ -0,0 +1,17 @@
+export type Calculable = {
+    base: number;
+    overhead: number;
+};
+export type CurrencyCode = "usd" | "gbp" | "eur" | "pln" | "jpy";
+export declare function withOverhead(input: Calculable, precision?: number): number;
+export declare function getOverheadAmount(input: Calculable, precision?: number): number;
+export declare function subtotal(input: Calculable, qty: number, precision?: number): {
+    netSubtotal: number;
+    overheadAmount: number;
+    grossSubtotal: number;
+};
+export declare function chainOverheads(base: number, ...overheads: number[]): number;
+export declare function roundDecimals(value: number, decimals?: number): number;
+export declare function toMinorUnits(amount: number, currency: string): number;
+export declare function fromMinorUnits(amount: number, currency: string): number;
+export declare const addCurrencySymbol: (value: number | string, currencyCode: CurrencyCode) => string;

package/dist/finance/index.js

@@ -0,0 +1,52 @@
+function normalizeFactor(factor) {
+    // integers >= 1 are percentages; 0 < factor <= 1 are fractions
+    return factor >= 1 ? factor / 100 : factor;
+}
+export function withOverhead(input, precision = 2) {
+    const factor = normalizeFactor(input.overhead);
+    return +(input.base * (1 + factor)).toFixed(precision);
+}
+export function getOverheadAmount(input, precision = 2) {
+    const factor = normalizeFactor(input.overhead);
+    return +(input.base * factor).toFixed(precision);
+}
+export function subtotal(input, qty, precision = 2) {
+    const factor = normalizeFactor(input.overhead);
+    const baseWithOverhead = +(input.base * (1 + factor)).toFixed(precision);
+    const netSubtotal = +(input.base * qty).toFixed(precision);
+    const grossSubtotal = +(baseWithOverhead * qty).toFixed(precision);
+    const overheadAmount = +(grossSubtotal - netSubtotal).toFixed(precision);
+    return {
+        netSubtotal,
+        overheadAmount,
+        grossSubtotal,
+    };
+}
+export function chainOverheads(base, ...overheads) {
+    return overheads.reduce((acc, overhead) => withOverhead({ base: acc, overhead }), base);
+}
+export function roundDecimals(value, decimals = 2) {
+    return parseFloat(value.toFixed(decimals));
+}
+export function toMinorUnits(amount, currency) {
+    const decimals = ["jpy"].includes(currency.toLowerCase()) ? 0 : 2;
+    return Math.round(amount * 10 ** decimals);
+}
+export function fromMinorUnits(amount, currency) {
+    const decimals = ["jpy"].includes(currency.toLowerCase()) ? 0 : 2;
+    return amount / 10 ** decimals;
+}
+export const addCurrencySymbol = (value, currencyCode) => {
+    switch (currencyCode.toLowerCase()) {
+        case "pln":
+            return `${value} zł`;
+        case "usd":
+            return `${value} $`;
+        case "gbp":
+            return `£${value}`;
+        case "eur":
+            return `€${value}`;
+        default:
+            return `${value} ${currencyCode}`;
+    }
+};

package/dist/format/create-id-from-date.d.ts

@@ -0,0 +1 @@
+export declare const createIdFromDate: () => string;

package/dist/format/create-id-from-date.js

@@ -0,0 +1,4 @@
+import { sanitizeForUrl } from "./format-url.js";
+export const createIdFromDate = () => {
+    return sanitizeForUrl(new Date().toISOString());
+};

package/dist/format/format-capitalize-string.d.ts

@@ -0,0 +1 @@
+export declare function capitalize(str: string): string;

package/dist/format/format-capitalize-string.js

@@ -0,0 +1,3 @@
+export function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}

package/dist/format/format-size.d.ts

@@ -0,0 +1 @@
+export declare function formatSize(bytes: number): string;

package/dist/format/format-size.js

@@ -0,0 +1,11 @@
+export function formatSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    const units = ['KB', 'MB', 'GB', 'TB', 'PB', 'EB'];
+    let i = -1;
+    do {
+        bytes /= 1024;
+        i++;
+    } while (bytes >= 1024 && i < units.length - 1);
+    return `${bytes.toFixed(2)} ${units[i]}`;
+}

package/dist/format/format-unit-suffix.d.ts

@@ -0,0 +1 @@
+export declare function formatUnitSuffix(input: string | number, suffix: string): string;

package/dist/format/format-unit-suffix.js

@@ -0,0 +1,6 @@
+export function formatUnitSuffix(input, suffix) {
+    const str = String(input).trim();
+    const match = str.match(/^(-?\d*\.?\d+)/);
+    const num = match ? match[1] : "0";
+    return `${num}${suffix}`;
+}

package/dist/format/format-url.d.ts

@@ -0,0 +1 @@
+export declare function sanitizeForUrl(input: string, separator?: '-' | '_'): string;

package/dist/format/format-url.js

@@ -0,0 +1,8 @@
+export function sanitizeForUrl(input, separator = '-') {
+    return input
+        .toLowerCase()
+        .normalize('NFD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .replace(/[^\w\s-]/g, '')
+        .replace(/\s+/g, separator);
+}

package/dist/format/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./replace-last-sement.js";
+export * from "./strip-slashes.js";
+export * from "./strip-trailing-slashes.js";
+export * from "./trim-whitespace.js";
+export * from "./format-url.js";
+export * from "./create-id-from-date.js";
+export * from "./format-capitalize-string.js";
+export * from "./format-size.js";
+export * from "./format-unit-suffix.js";
+export * from "./sanitize.js";
+export * from "./truncate-text.js";
+export * from "./to-kebab-case.js";

package/dist/format/index.js

@@ -0,0 +1,12 @@
+export * from "./replace-last-sement.js";
+export * from "./strip-slashes.js";
+export * from "./strip-trailing-slashes.js";
+export * from "./trim-whitespace.js";
+export * from "./format-url.js";
+export * from "./create-id-from-date.js";
+export * from "./format-capitalize-string.js";
+export * from "./format-size.js";
+export * from "./format-unit-suffix.js";
+export * from "./sanitize.js";
+export * from "./truncate-text.js";
+export * from "./to-kebab-case.js";

package/dist/format/replace-last-sement.d.ts

@@ -0,0 +1 @@
+export declare function replaceLastSegment(path: string, replacement: string): string;

package/dist/format/replace-last-sement.js

@@ -0,0 +1,13 @@
+export function replaceLastSegment(path, replacement) {
+    const hasTrailingSlash = path.endsWith("/");
+    const segments = path
+        .split("/")
+        .filter((seg, i, arr) => i < arr.length - 1 || seg);
+    if (segments.length > 0) {
+        segments[segments.length - 1] = replacement;
+    }
+    else {
+        segments.push(replacement);
+    }
+    return segments.join("/") + (hasTrailingSlash ? "/" : "");
+}

package/dist/format/sanitize.d.ts

@@ -0,0 +1,11 @@
+type Sanitizer = (val: any) => any;
+export type SanitizerContext = {
+    value: any;
+    document: any;
+    parent?: any;
+    index?: number;
+    path: string;
+};
+export type SanitizerEntry = [string, Sanitizer];
+export declare function applySanitizers(obj: any, sanitizers: SanitizerEntry[]): any;
+export {};

package/dist/format/sanitize.js

@@ -0,0 +1,53 @@
+import { getAtPath, setAtPath } from "../accessors/index.js";
+export function applySanitizers(obj, sanitizers) {
+    const cloned = JSON.parse(JSON.stringify(obj));
+    for (const [path, fn] of sanitizers) {
+        const isWildcard = path.includes("[]");
+        const pathsToSanitize = isWildcard ? expandPaths(cloned, path) : [path];
+        for (const resolvedPath of pathsToSanitize) {
+            const value = getAtPath(cloned, resolvedPath);
+            if (value === undefined)
+                continue;
+            const context = {
+                value,
+                document: cloned,
+                path: resolvedPath,
+            };
+            if (isWildcard) {
+                const indexMatch = resolvedPath.match(/\[(\d+)\]/);
+                const index = indexMatch ? Number(indexMatch[1]) : undefined;
+                context.index = index;
+                const parentPath = resolvedPath.replace(/\.\w+$/, ""); // up one level
+                context.parent = getAtPath(cloned, parentPath);
+            }
+            setAtPath(cloned, resolvedPath, fn(context));
+        }
+    }
+    return cloned;
+}
+function expandPaths(obj, wildcardPath) {
+    const segments = wildcardPath.split(".");
+    const result = [];
+    function recurse(current, pathParts, currentPath) {
+        if (!pathParts.length) {
+            result.push(currentPath.join("."));
+            return;
+        }
+        const part = pathParts[0];
+        const match = part.match(/^(\w+)\[\]$/);
+        if (match) {
+            const key = match[1];
+            const array = current?.[key];
+            if (!Array.isArray(array))
+                return;
+            for (let i = 0; i < array.length; i++) {
+                recurse(array[i], pathParts.slice(1), [...currentPath, `${key}[${i}]`]);
+            }
+        }
+        else {
+            recurse(current?.[part], pathParts.slice(1), [...currentPath, part]);
+        }
+    }
+    recurse(obj, segments, []);
+    return result;
+}

package/dist/format/strip-slashes.d.ts

@@ -0,0 +1 @@
+export declare const stripSlashes: (str: string) => string;

package/dist/format/strip-slashes.js

@@ -0,0 +1 @@
+export const stripSlashes = (str) => str.replace(/\//g, '');

package/dist/format/strip-trailing-slashes.d.ts

@@ -0,0 +1 @@
+export declare const stripTrailingSlashes: (str: string) => string;

package/dist/format/strip-trailing-slashes.js

@@ -0,0 +1 @@
+export const stripTrailingSlashes = (str) => str.replace(/\s+/g, '');

package/dist/format/to-kebab-case.d.ts

@@ -0,0 +1 @@
+export declare function toKebabCase(str: string): string;

package/dist/format/to-kebab-case.js

@@ -0,0 +1,7 @@
+export function toKebabCase(str) {
+    return str
+        .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+        .replace(/([A-Z])([A-Z][a-z])/g, "$1-$2")
+        .replace(/^([A-Z])/, "-$1")
+        .toLowerCase();
+}

package/dist/format/trim-whitespace.d.ts

@@ -0,0 +1 @@
+export declare const trimWhitespace: (str: string) => string;

package/dist/format/trim-whitespace.js

@@ -0,0 +1 @@
+export const trimWhitespace = (str) => str.replace(/\/+$/g, '');

package/dist/format/truncate-text.d.ts

@@ -0,0 +1 @@
+export declare function truncateText(text: string, limit: number): string;

package/dist/format/truncate-text.js

@@ -0,0 +1,5 @@
+export function truncateText(text, limit) {
+    if (text.length <= limit)
+        return text;
+    return text.slice(0, limit).trimEnd() + "…";
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./accessors/index.js";
+export * from "./parsers/index.js";
+export * from "./data/index.js";
+export * from "./format/index.js";
+export * from "./processors/index.js";
+export * from "./array/index.js";
+export * from "./date/index.js";
+export * from "./finance/index.js";

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from "./accessors/index.js";
+export * from "./parsers/index.js";
+export * from "./data/index.js";
+export * from "./format/index.js";
+export * from "./processors/index.js";
+export * from "./array/index.js";
+export * from "./date/index.js";
+export * from "./finance/index.js";

package/dist/parsers/clone-object.d.ts

@@ -0,0 +1 @@
+export declare function cloneObject(obj: Record<string, any> | Record<string, any>[]): any;

package/dist/parsers/clone-object.js

@@ -0,0 +1,3 @@
+export function cloneObject(obj) {
+    return JSON.parse(JSON.stringify(obj));
+}

package/dist/parsers/coerce-numeric-strings.d.ts

@@ -0,0 +1 @@
+export declare function coerceNumericStrings(obj: Record<string, any> | Record<string, any>[]): any;

package/dist/parsers/coerce-numeric-strings.js

@@ -0,0 +1,16 @@
+export function coerceNumericStrings(obj) {
+    if (Array.isArray(obj)) {
+        return obj.map(coerceNumericStrings);
+    }
+    if (obj && typeof obj === "object") {
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+            result[key] = coerceNumericStrings(value);
+        }
+        return result;
+    }
+    if (typeof obj === "string" && /^-?\d+(\.\d+)?$/.test(obj)) {
+        return parseFloat(obj);
+    }
+    return obj;
+}

package/dist/parsers/escape-html.d.ts

@@ -0,0 +1 @@
+export declare function escapeHTML(str: string): string;

package/dist/parsers/escape-html.js

@@ -0,0 +1,8 @@
+export function escapeHTML(str) {
+    return str
+        .replace(/&/g, "&")
+        .replace(/"/g, """)
+        .replace(/'/g, "'")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;");
+}

package/dist/parsers/flatten-deep.d.ts

@@ -0,0 +1 @@
+export declare function flattenDeep(obj: any): any[];

package/dist/parsers/flatten-deep.js

@@ -0,0 +1,3 @@
+export function flattenDeep(obj) {
+    return Object.values(obj).flatMap((v) => typeof v === "object" && !Array.isArray(v) ? flattenDeep(v) : v);
+}

package/dist/parsers/flatten-object-keys.d.ts

@@ -0,0 +1,8 @@
+type FlattenOptions = {
+    input: Record<string, any>;
+    prefix?: string;
+    result?: Record<string, any>;
+    ignore?: (value: any, key: string, path: string) => boolean;
+};
+export declare function flattenObjectKeys({ input, prefix, result, ignore, }: FlattenOptions): Record<string, any>;
+export {};

package/dist/parsers/flatten-object-keys.js

@@ -0,0 +1,17 @@
+export function flattenObjectKeys({ input, prefix = "", result = {}, ignore, }) {
+    for (const [key, value] of Object.entries(input)) {
+        const path = prefix ? `${prefix}.${key}` : key;
+        const isObject = value &&
+            typeof value === "object" &&
+            !Array.isArray(value) &&
+            !(value instanceof Date);
+        const stop = ignore?.(value, key, path) ?? false;
+        if (isObject && !stop) {
+            flattenObjectKeys({ input: value, prefix: path, result, ignore });
+        }
+        else {
+            result[path] = value;
+        }
+    }
+    return result;
+}

package/dist/parsers/fn-parser.d.ts

@@ -0,0 +1,17 @@
+export declare function getFunctionParamNames(fn: Function): string[];
+export declare function parseMethodsObject(ob: any): string[];
+export declare function getMethodFromString(initializer: any, path: string): any;
+export declare function callMethodFromString(initializer: any, path: string, ...args: any[]): any;
+export declare function inspectMethod(initializer: any, path: string): {
+    isFunction: boolean;
+    argCount: any;
+    paramNames: string[];
+    signature: any;
+    message?: undefined;
+} | {
+    isFunction: boolean;
+    message: string;
+    argCount?: undefined;
+    paramNames?: undefined;
+    signature?: undefined;
+};

package/dist/parsers/fn-parser.js

@@ -0,0 +1,80 @@
+export function getFunctionParamNames(fn) {
+    const fnStr = fn.toString();
+    // Match function signature: handles regular functions, arrow functions, etc.
+    const match = fnStr.match(/^[\w\s]*?\(?([^\)]*)\)?\s*=>|function[^\(]*\(([^\)]*)\)/);
+    const args = match ? match[1] || match[2] : '';
+    // Split by comma and trim
+    return args
+        .split(',')
+        .map((arg) => arg.trim())
+        .filter((arg) => arg.length > 0);
+}
+export function parseMethodsObject(ob) {
+    const result = [];
+    const visited = new WeakSet();
+    const walk = (obj, path = []) => {
+        if (typeof obj !== 'object' || obj === null || visited.has(obj))
+            return;
+        visited.add(obj);
+        for (const key of Object.keys(obj)) {
+            const value = obj[key];
+            const currentPath = [...path, key];
+            if (typeof value === 'function') {
+                result.push(currentPath.join('.'));
+            }
+            else if (typeof value === 'object') {
+                walk(value, currentPath);
+            }
+        }
+    };
+    walk(ob);
+    return result;
+}
+export function getMethodFromString(initializer, path) {
+    const parts = path.split('.');
+    let current = initializer;
+    for (const part of parts) {
+        if (current && part in current) {
+            current = current[part];
+        }
+        else {
+            throw new Error(`Invalid path: ${path}`);
+        }
+    }
+    return current;
+}
+export function callMethodFromString(initializer, path, ...args) {
+    const fn = getMethodFromString(initializer, path);
+    if (typeof fn === 'function') {
+        return fn(...args);
+    }
+    else {
+        throw new Error(`Path does not point to a function: ${path}`);
+    }
+}
+export function inspectMethod(initializer, path) {
+    const parts = path.split('.');
+    let current = initializer;
+    for (const part of parts) {
+        if (current && part in current) {
+            current = current[part];
+        }
+        else {
+            throw new Error(`Invalid faker path: ${path}`);
+        }
+    }
+    if (typeof current === 'function') {
+        return {
+            isFunction: true,
+            argCount: current.length,
+            paramNames: getFunctionParamNames(current),
+            signature: current.toString().split('\n')[0] // First line of function
+        };
+    }
+    else {
+        return {
+            isFunction: false,
+            message: 'Not a function'
+        };
+    }
+}

package/dist/parsers/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./clone-object.js";
+export * from "./coerce-numeric-strings.js";
+export * from "./is-colon-separated.js";
+export * from "./parse-string-to-object.js";
+export * from "./escape-html.js";
+export * from "./flatten-deep.js";
+export * from "./flatten-object-keys.js";
+export * from "./map-filter.js";
+export * from "./omit-keys-deep.js";
+export * from "./style/index.js";

package/dist/parsers/index.js

@@ -0,0 +1,10 @@
+export * from "./clone-object.js";
+export * from "./coerce-numeric-strings.js";
+export * from "./is-colon-separated.js";
+export * from "./parse-string-to-object.js";
+export * from "./escape-html.js";
+export * from "./flatten-deep.js";
+export * from "./flatten-object-keys.js";
+export * from "./map-filter.js";
+export * from "./omit-keys-deep.js";
+export * from "./style/index.js";

package/dist/parsers/is-colon-separated.d.ts

@@ -0,0 +1 @@
+export declare function isColonSeparated(str: string): boolean;

package/dist/parsers/is-colon-separated.js

@@ -0,0 +1,3 @@
+export function isColonSeparated(str) {
+    return (str.match(/:/g) || []).length === 1;
+}

package/dist/parsers/map-filter.d.ts

@@ -0,0 +1 @@
+export declare function mapFilter<T, U>(array: T[], mapper: (item: T, index: number) => U | undefined | null): U[];

package/dist/parsers/map-filter.js

@@ -0,0 +1,10 @@
+export function mapFilter(array, mapper) {
+    const result = [];
+    for (let i = 0; i < array.length; i++) {
+        const mapped = mapper(array[i], i);
+        if (mapped !== undefined && mapped !== null) {
+            result.push(mapped);
+        }
+    }
+    return result;
+}

package/dist/parsers/omit-keys-deep.d.ts

@@ -0,0 +1,9 @@
+export interface TrimOptions {
+    omitKeys?: string[];
+    stripNull?: boolean;
+    stripUndefined?: boolean;
+    stripEmptyStrings?: boolean;
+    stripEmptyArrays?: boolean;
+    stripEmptyObjects?: boolean;
+}
+export declare function omitKeysDeep(obj: Record<string, any>, options?: TrimOptions): Record<string, any>;

package/dist/parsers/omit-keys-deep.js

@@ -0,0 +1,43 @@
+export function omitKeysDeep(obj, options = {}) {
+    const { omitKeys = [], stripNull = true, stripUndefined = true, stripEmptyStrings = false, stripEmptyArrays = false, stripEmptyObjects = false, } = options;
+    const omitPaths = new Set(omitKeys);
+    // const clone = JSON.parse(JSON.stringify(obj));
+    function recurse(o, path = []) {
+        if (Array.isArray(o)) {
+            const cleanedArray = o
+                .map((item, i) => recurse(item, path.concat(String(i))))
+                .filter((v) => {
+                return !shouldStrip(v);
+            });
+            return cleanedArray;
+        }
+        if (typeof o === "object" && o !== null) {
+            const result = {};
+            for (const [k, v] of Object.entries(o)) {
+                const fullPath = path.concat(k).join(".");
+                if (omitPaths.has(fullPath))
+                    continue;
+                const value = recurse(v, path.concat(k));
+                if (!shouldStrip(value)) {
+                    result[k] = value;
+                }
+            }
+            return result;
+        }
+        return o;
+    }
+    function shouldStrip(value) {
+        return ((stripUndefined && value === undefined) ||
+            (stripNull && value === null) ||
+            (stripEmptyStrings && value === "") ||
+            (stripEmptyArrays && Array.isArray(value) && value.length === 0) ||
+            (stripEmptyObjects && isEmptyObject(value)));
+    }
+    return recurse(obj);
+}
+function isEmptyObject(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        Object.keys(value).length === 0);
+}

package/dist/parsers/parse-string-to-object.d.ts

@@ -0,0 +1 @@
+export declare function parseStringToObject(input: string): Record<string, string>;

package/dist/parsers/parse-string-to-object.js

@@ -0,0 +1,8 @@
+export function parseStringToObject(input) {
+    return input.split(',').reduce((acc, pair) => {
+        const [key, value] = pair.split(':').map((s) => s.trim());
+        if (key)
+            acc[key] = value;
+        return acc;
+    }, {});
+}

package/dist/parsers/style/index.d.ts

@@ -0,0 +1 @@
+export * from "./parse-border-string.js";

package/dist/parsers/style/index.js

@@ -0,0 +1 @@
+export * from "./parse-border-string.js";

package/dist/parsers/style/parse-border-string.d.ts

@@ -0,0 +1,5 @@
+export declare function parseBorderString(border: string): {
+    width: string;
+    style: string;
+    color: string;
+};

package/dist/parsers/style/parse-border-string.js

@@ -0,0 +1,8 @@
+export function parseBorderString(border) {
+    const regex = /^([\d.]+[a-z%]+)\s+(\w+)\s+(.+)$/;
+    const match = border.match(regex);
+    if (!match)
+        return { width: "", style: "", color: "" };
+    const [, width, style, color] = match;
+    return { width, style, color };
+}

package/dist/processors/deep-merge.d.ts

@@ -0,0 +1 @@
+export declare function deepMerge<T extends object, U extends object>(target: T, source: U): T & U;

package/dist/processors/deep-merge.js

@@ -0,0 +1,18 @@
+export function deepMerge(target, source) {
+    const result = { ...target };
+    for (const key in source) {
+        const sourceValue = source[key];
+        const targetValue = target[key];
+        if (sourceValue &&
+            targetValue &&
+            typeof sourceValue === "object" &&
+            typeof targetValue === "object" &&
+            !Array.isArray(sourceValue)) {
+            result[key] = deepMerge(targetValue, sourceValue);
+        }
+        else {
+            result[key] = sourceValue;
+        }
+    }
+    return result;
+}

package/dist/processors/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./process-data-in-chunks.js";
+export * from "./deep-merge.js";

package/dist/processors/index.js

@@ -0,0 +1,2 @@
+export * from "./process-data-in-chunks.js";
+export * from "./deep-merge.js";

package/dist/processors/process-data-in-chunks.d.ts

@@ -0,0 +1,5 @@
+export declare function processInChunks<T>(data: T[], chunkSize: number, processChunk: (chunk: T[]) => Promise<{
+    ok: boolean;
+    error?: string;
+}>, logger?: (level: "info" | "error", message: string, meta?: any) => void): Promise<any>;
+export declare function arrayChunk<T>(arr: T[], size: number, logger?: (level: "info" | "error", message: string, meta?: any) => void): T[][];

package/dist/processors/process-data-in-chunks.js

@@ -0,0 +1,21 @@
+export async function processInChunks(data, chunkSize, processChunk, logger = () => { }) {
+    for (let i = 0; i < data.length; i += chunkSize) {
+        const chunk = data.slice(i, i + chunkSize);
+        logger("info", `Processing chunk ${i}-${i + chunkSize}...`);
+        const res = await processChunk(chunk);
+        if (!res.ok) {
+            logger("error", `Chunk ${i}-${i + chunkSize} failed:`, res.error);
+            return res;
+        }
+        logger("info", `Successfully processed batch ${i}-${i + chunkSize}`);
+    }
+    return { ok: true, message: "All chunks processed successfully." };
+}
+export function arrayChunk(arr, size, logger = () => { }) {
+    const chunks = [];
+    for (let i = 0; i < arr.length; i += size) {
+        chunks.push(arr.slice(i, i + size));
+    }
+    logger("info", `Split array into ${chunks.length} chunks of size ${size}`);
+    return chunks;
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@pogodisco/ts-kit",
+  "version": "0.0.1",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "author": "Jakub Bystroński",
+  "description": "typescript utility kit",
+  "keywords": [
+    "tools",
+    "utilities",
+    "typescript"
+  ],
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "prepublishOnly": "npm run build",
+    "build": "tsc",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "date-fns": "^4.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  }
+}