@glissandoo/lib 1.123.2 → 1.124.0-dev.219.1

package/helpers/currency.js

@@ -0,0 +1,346 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCurrencyInputValue = exports.formatCurrencyInputValue = exports.formatCurrencyCents = exports.formatCurrencyAmount = exports.getMarketplaceCurrencyOptions = exports.getCurrencyInfo = exports.getCurrencySymbol = exports.countryToCurrency = exports.COUNTRY_TO_CURRENCY = exports.DEFAULT_CURRENCY = exports.roundMarketplaceCurrencyCents = exports.normalizeMarketplaceCurrency = exports.isSupportedMarketplaceCurrency = exports.getDefaultMarketplaceCurrency = exports.getCurrencyForCountry = exports.convertCurrencyCents = exports.buildCurrencyConversionResult = exports.MARKETPLACE_CURRENCY_SYMBOL_LOCALES = exports.MARKETPLACE_CURRENCY_CODES = void 0;
+const currencyConversion_1 = require("./currencyConversion");
+var currencyConversion_2 = require("./currencyConversion");
+Object.defineProperty(exports, "MARKETPLACE_CURRENCY_CODES", { enumerable: true, get: function () { return currencyConversion_2.MARKETPLACE_CURRENCY_CODES; } });
+Object.defineProperty(exports, "MARKETPLACE_CURRENCY_SYMBOL_LOCALES", { enumerable: true, get: function () { return currencyConversion_2.MARKETPLACE_CURRENCY_SYMBOL_LOCALES; } });
+Object.defineProperty(exports, "buildCurrencyConversionResult", { enumerable: true, get: function () { return currencyConversion_2.buildCurrencyConversionResult; } });
+Object.defineProperty(exports, "convertCurrencyCents", { enumerable: true, get: function () { return currencyConversion_2.convertCurrencyCents; } });
+Object.defineProperty(exports, "getCurrencyForCountry", { enumerable: true, get: function () { return currencyConversion_2.getCurrencyForCountry; } });
+Object.defineProperty(exports, "getDefaultMarketplaceCurrency", { enumerable: true, get: function () { return currencyConversion_2.getDefaultMarketplaceCurrency; } });
+Object.defineProperty(exports, "isSupportedMarketplaceCurrency", { enumerable: true, get: function () { return currencyConversion_2.isSupportedMarketplaceCurrency; } });
+Object.defineProperty(exports, "normalizeMarketplaceCurrency", { enumerable: true, get: function () { return currencyConversion_2.normalizeMarketplaceCurrency; } });
+Object.defineProperty(exports, "roundMarketplaceCurrencyCents", { enumerable: true, get: function () { return currencyConversion_2.roundMarketplaceCurrencyCents; } });
+const CURRENCY_SYMBOL_LOCALE = {
+    ...currencyConversion_1.MARKETPLACE_CURRENCY_SYMBOL_LOCALES,
+    PLN: 'pl-PL',
+    CZK: 'cs-CZ',
+    HUF: 'hu-HU',
+    RON: 'ro-RO',
+    BGN: 'bg-BG',
+    HRK: 'hr-HR',
+};
+exports.DEFAULT_CURRENCY = 'EUR';
+exports.COUNTRY_TO_CURRENCY = {
+    AD: 'EUR',
+    AE: 'AED',
+    AF: 'AFN',
+    AG: 'XCD',
+    AI: 'XCD',
+    AL: 'ALL',
+    AM: 'AMD',
+    AO: 'AOA',
+    AQ: 'USD',
+    AR: 'ARS',
+    AS: 'USD',
+    AT: 'EUR',
+    AU: 'AUD',
+    AW: 'AWG',
+    AX: 'EUR',
+    AZ: 'AZN',
+    BA: 'BAM',
+    BB: 'BBD',
+    BD: 'BDT',
+    BE: 'EUR',
+    BF: 'XOF',
+    BG: 'BGN',
+    BH: 'BHD',
+    BI: 'BIF',
+    BJ: 'XOF',
+    BL: 'EUR',
+    BM: 'BMD',
+    BN: 'BND',
+    BO: 'BOB',
+    BQ: 'USD',
+    BR: 'BRL',
+    BS: 'BSD',
+    BT: 'BTN',
+    BV: 'NOK',
+    BW: 'BWP',
+    BY: 'BYN',
+    BZ: 'BZD',
+    CA: 'CAD',
+    CC: 'AUD',
+    CD: 'CDF',
+    CF: 'XAF',
+    CG: 'XAF',
+    CH: 'CHF',
+    CI: 'XOF',
+    CK: 'NZD',
+    CL: 'CLP',
+    CM: 'XAF',
+    CN: 'CNY',
+    CO: 'COP',
+    CR: 'CRC',
+    CU: 'CUP',
+    CV: 'CVE',
+    CW: 'ANG',
+    CX: 'AUD',
+    CY: 'EUR',
+    CZ: 'CZK',
+    DE: 'EUR',
+    DJ: 'DJF',
+    DK: 'DKK',
+    DM: 'XCD',
+    DO: 'DOP',
+    DZ: 'DZD',
+    EC: 'USD',
+    EE: 'EUR',
+    EG: 'EGP',
+    EH: 'MAD',
+    ER: 'ERN',
+    ES: 'EUR',
+    ET: 'ETB',
+    FI: 'EUR',
+    FJ: 'FJD',
+    FK: 'FKP',
+    FM: 'USD',
+    FO: 'DKK',
+    FR: 'EUR',
+    GA: 'XAF',
+    GB: 'GBP',
+    GD: 'XCD',
+    GE: 'GEL',
+    GF: 'EUR',
+    GG: 'GBP',
+    GH: 'GHS',
+    GI: 'GIP',
+    GL: 'DKK',
+    GM: 'GMD',
+    GN: 'GNF',
+    GP: 'EUR',
+    GQ: 'XAF',
+    GR: 'EUR',
+    GS: 'GBP',
+    GT: 'GTQ',
+    GU: 'USD',
+    GW: 'XOF',
+    GY: 'GYD',
+    HK: 'HKD',
+    HM: 'AUD',
+    HN: 'HNL',
+    HR: 'EUR',
+    HT: 'HTG',
+    HU: 'HUF',
+    ID: 'IDR',
+    IE: 'EUR',
+    IL: 'ILS',
+    IM: 'GBP',
+    IN: 'INR',
+    IO: 'USD',
+    IQ: 'IQD',
+    IR: 'IRR',
+    IS: 'ISK',
+    IT: 'EUR',
+    JE: 'GBP',
+    JM: 'JMD',
+    JO: 'JOD',
+    JP: 'JPY',
+    KE: 'KES',
+    KG: 'KGS',
+    KH: 'KHR',
+    KI: 'AUD',
+    KM: 'KMF',
+    KN: 'XCD',
+    KP: 'KPW',
+    KR: 'KRW',
+    KW: 'KWD',
+    KY: 'KYD',
+    KZ: 'KZT',
+    LA: 'LAK',
+    LB: 'LBP',
+    LC: 'XCD',
+    LI: 'CHF',
+    LK: 'LKR',
+    LR: 'LRD',
+    LS: 'LSL',
+    LT: 'EUR',
+    LU: 'EUR',
+    LV: 'EUR',
+    LY: 'LYD',
+    MA: 'MAD',
+    MC: 'EUR',
+    MD: 'MDL',
+    ME: 'EUR',
+    MF: 'EUR',
+    MG: 'MGA',
+    MH: 'USD',
+    MK: 'MKD',
+    ML: 'XOF',
+    MM: 'MMK',
+    MN: 'MNT',
+    MO: 'MOP',
+    MP: 'USD',
+    MQ: 'EUR',
+    MR: 'MRU',
+    MS: 'XCD',
+    MT: 'EUR',
+    MU: 'MUR',
+    MV: 'MVR',
+    MW: 'MWK',
+    MX: 'MXN',
+    MY: 'MYR',
+    MZ: 'MZN',
+    NA: 'NAD',
+    NC: 'XPF',
+    NE: 'XOF',
+    NF: 'AUD',
+    NG: 'NGN',
+    NI: 'NIO',
+    NL: 'EUR',
+    NO: 'NOK',
+    NP: 'NPR',
+    NR: 'AUD',
+    NU: 'NZD',
+    NZ: 'NZD',
+    OM: 'OMR',
+    PA: 'PAB',
+    PE: 'PEN',
+    PF: 'XPF',
+    PG: 'PGK',
+    PH: 'PHP',
+    PK: 'PKR',
+    PL: 'PLN',
+    PM: 'EUR',
+    PN: 'NZD',
+    PR: 'USD',
+    PS: 'ILS',
+    PT: 'EUR',
+    PW: 'USD',
+    PY: 'PYG',
+    QA: 'QAR',
+    RE: 'EUR',
+    RO: 'RON',
+    RS: 'RSD',
+    RU: 'RUB',
+    RW: 'RWF',
+    SA: 'SAR',
+    SB: 'SBD',
+    SC: 'SCR',
+    SD: 'SDG',
+    SE: 'SEK',
+    SG: 'SGD',
+    SH: 'SHP',
+    SI: 'EUR',
+    SJ: 'NOK',
+    SK: 'EUR',
+    SL: 'SLE',
+    SM: 'EUR',
+    SN: 'XOF',
+    SO: 'SOS',
+    SR: 'SRD',
+    SS: 'SSP',
+    ST: 'STN',
+    SV: 'USD',
+    SX: 'ANG',
+    SY: 'SYP',
+    SZ: 'SZL',
+    TC: 'USD',
+    TD: 'XAF',
+    TF: 'EUR',
+    TG: 'XOF',
+    TH: 'THB',
+    TJ: 'TJS',
+    TK: 'NZD',
+    TL: 'USD',
+    TM: 'TMT',
+    TN: 'TND',
+    TO: 'TOP',
+    TR: 'TRY',
+    TT: 'TTD',
+    TV: 'AUD',
+    TW: 'TWD',
+    TZ: 'TZS',
+    UA: 'UAH',
+    UG: 'UGX',
+    UM: 'USD',
+    US: 'USD',
+    UY: 'UYU',
+    UZ: 'UZS',
+    VA: 'EUR',
+    VC: 'XCD',
+    VE: 'VES',
+    VG: 'USD',
+    VI: 'USD',
+    VN: 'VND',
+    VU: 'VUV',
+    WF: 'XPF',
+    WS: 'WST',
+    XK: 'EUR',
+    YE: 'YER',
+    YT: 'EUR',
+    ZA: 'ZAR',
+    ZM: 'ZMW',
+    ZW: 'ZWG',
+};
+const countryToCurrency = (country) => {
+    if (!country)
+        return exports.DEFAULT_CURRENCY;
+    return exports.COUNTRY_TO_CURRENCY[country.toUpperCase()] || exports.DEFAULT_CURRENCY;
+};
+exports.countryToCurrency = countryToCurrency;
+const getCurrencySymbol = (currency, locale) => {
+    try {
+        const symbolLocale = locale ?? CURRENCY_SYMBOL_LOCALE[currency] ?? 'en-US';
+        const parts = new Intl.NumberFormat(symbolLocale, {
+            style: 'currency',
+            currency,
+            currencyDisplay: 'symbol',
+        }).formatToParts(0);
+        const symbolPart = parts.find((p) => p.type === 'currency');
+        return symbolPart?.value || currency;
+    }
+    catch {
+        return currency;
+    }
+};
+exports.getCurrencySymbol = getCurrencySymbol;
+const getCurrencyInfo = (currency) => {
+    const code = currency.trim().toUpperCase();
+    const symbol = (0, exports.getCurrencySymbol)(code);
+    return {
+        code,
+        symbol,
+        symbolIsCode: symbol.trim().toUpperCase() === code,
+        prefixed: code !== 'EUR',
+        decimalSeparator: code === 'EUR' ? ',' : '.',
+    };
+};
+exports.getCurrencyInfo = getCurrencyInfo;
+const getMarketplaceCurrencyOptions = () => currencyConversion_1.MARKETPLACE_CURRENCY_CODES.map((code) => ({
+    ...(0, exports.getCurrencyInfo)(code),
+    code,
+}));
+exports.getMarketplaceCurrencyOptions = getMarketplaceCurrencyOptions;
+const formatCurrencyAmount = (amount, currency, fractionDigits = 2) => {
+    const { code, symbol, prefixed } = (0, exports.getCurrencyInfo)(currency);
+    const locale = code === 'EUR' ? 'de-DE' : 'en-US';
+    const formattedAmount = new Intl.NumberFormat(locale, {
+        minimumFractionDigits: fractionDigits,
+        maximumFractionDigits: fractionDigits,
+    }).format(amount);
+    return prefixed ? `${symbol}${formattedAmount}` : `${formattedAmount} ${symbol}`;
+};
+exports.formatCurrencyAmount = formatCurrencyAmount;
+const formatCurrencyCents = (cents, currency, fractionDigits = 2) => {
+    if (cents === null || cents === undefined)
+        return '\u2014';
+    return (0, exports.formatCurrencyAmount)(cents / 100, currency, fractionDigits);
+};
+exports.formatCurrencyCents = formatCurrencyCents;
+const formatCurrencyInputValue = (value, currency) => {
+    if (value === undefined || value === '')
+        return '';
+    const { symbol, prefixed } = (0, exports.getCurrencyInfo)(currency);
+    return prefixed ? `${symbol}${value}` : String(value);
+};
+exports.formatCurrencyInputValue = formatCurrencyInputValue;
+const parseCurrencyInputValue = (value, currency) => {
+    if (!value)
+        return 0;
+    const { symbol } = (0, exports.getCurrencyInfo)(currency);
+    const numericValue = value.replace(symbol, '').replace(/,/g, '').trim();
+    return Number(numericValue);
+};
+exports.parseCurrencyInputValue = parseCurrencyInputValue;

package/helpers/currencyConversion.d.ts

@@ -0,0 +1,45 @@
+export declare const MARKETPLACE_CURRENCY_SYMBOL_LOCALES: {
+    readonly EUR: "de-DE";
+    readonly USD: "en-US";
+    readonly GBP: "en-GB";
+    readonly CHF: "de-CH";
+    readonly CAD: "en-CA";
+    readonly AUD: "en-AU";
+    readonly JPY: "ja-JP";
+    readonly SEK: "sv-SE";
+    readonly NOK: "nb-NO";
+    readonly DKK: "da-DK";
+};
+export type MarketplaceCurrencyCode = keyof typeof MARKETPLACE_CURRENCY_SYMBOL_LOCALES;
+export declare const MARKETPLACE_CURRENCY_CODES: MarketplaceCurrencyCode[];
+export interface CurrencyExchangeRateSnapshot {
+    baseCurrency: MarketplaceCurrencyCode;
+    targetCurrency: MarketplaceCurrencyCode;
+    rate: number;
+    rateDate: string;
+    provider: string;
+    fetchedAt: string;
+}
+export interface CurrencyDefaultingInput {
+    savedCurrency?: string | null;
+    country?: string | null;
+    locale?: string | null;
+    fallbackCurrency?: MarketplaceCurrencyCode;
+}
+export interface CurrencyConversionResult {
+    baseAmountCents: number;
+    baseCurrency: MarketplaceCurrencyCode;
+    convertedAmountCents: number;
+    targetCurrency: MarketplaceCurrencyCode;
+    rate: number;
+    rateDate: string;
+    rateProvider: string;
+}
+export declare const MARKETPLACE_CURRENCY_ROUNDING_CENTS: Record<MarketplaceCurrencyCode, number>;
+export declare const isSupportedMarketplaceCurrency: (value: unknown) => value is MarketplaceCurrencyCode;
+export declare const normalizeMarketplaceCurrency: (value: unknown) => MarketplaceCurrencyCode | undefined;
+export declare const getCurrencyForCountry: (country: string | null | undefined) => MarketplaceCurrencyCode | undefined;
+export declare const getDefaultMarketplaceCurrency: ({ savedCurrency, country, locale, fallbackCurrency, }: CurrencyDefaultingInput) => MarketplaceCurrencyCode;
+export declare const roundMarketplaceCurrencyCents: (amountCents: number, currency: MarketplaceCurrencyCode) => number;
+export declare const convertCurrencyCents: (baseAmountCents: number, rate: number, targetCurrency?: MarketplaceCurrencyCode) => number;
+export declare const buildCurrencyConversionResult: (baseAmountCents: number, rateSnapshot: CurrencyExchangeRateSnapshot) => CurrencyConversionResult;

package/helpers/currencyConversion.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCurrencyConversionResult = exports.convertCurrencyCents = exports.roundMarketplaceCurrencyCents = exports.getDefaultMarketplaceCurrency = exports.getCurrencyForCountry = exports.normalizeMarketplaceCurrency = exports.isSupportedMarketplaceCurrency = exports.MARKETPLACE_CURRENCY_ROUNDING_CENTS = exports.MARKETPLACE_CURRENCY_CODES = exports.MARKETPLACE_CURRENCY_SYMBOL_LOCALES = void 0;
+exports.MARKETPLACE_CURRENCY_SYMBOL_LOCALES = {
+    EUR: 'de-DE',
+    USD: 'en-US',
+    GBP: 'en-GB',
+    CHF: 'de-CH',
+    CAD: 'en-CA',
+    AUD: 'en-AU',
+    JPY: 'ja-JP',
+    SEK: 'sv-SE',
+    NOK: 'nb-NO',
+    DKK: 'da-DK',
+};
+exports.MARKETPLACE_CURRENCY_CODES = Object.keys(exports.MARKETPLACE_CURRENCY_SYMBOL_LOCALES);
+exports.MARKETPLACE_CURRENCY_ROUNDING_CENTS = {
+    EUR: 50,
+    USD: 100,
+    GBP: 100,
+    CHF: 100,
+    CAD: 100,
+    AUD: 100,
+    JPY: 10000,
+    SEK: 100,
+    NOK: 100,
+    DKK: 100,
+};
+const COUNTRY_CURRENCY_MAP = {
+    AD: 'EUR',
+    AT: 'EUR',
+    AU: 'AUD',
+    BE: 'EUR',
+    CA: 'CAD',
+    CH: 'CHF',
+    CY: 'EUR',
+    DE: 'EUR',
+    DK: 'DKK',
+    EE: 'EUR',
+    ES: 'EUR',
+    FI: 'EUR',
+    FR: 'EUR',
+    GB: 'GBP',
+    GR: 'EUR',
+    IE: 'EUR',
+    IT: 'EUR',
+    JP: 'JPY',
+    LT: 'EUR',
+    LU: 'EUR',
+    LV: 'EUR',
+    MT: 'EUR',
+    NL: 'EUR',
+    NO: 'NOK',
+    PT: 'EUR',
+    SE: 'SEK',
+    SI: 'EUR',
+    SK: 'EUR',
+    US: 'USD',
+};
+const isSupportedMarketplaceCurrency = (value) => typeof value === 'string' &&
+    exports.MARKETPLACE_CURRENCY_CODES.includes(value.trim().toUpperCase());
+exports.isSupportedMarketplaceCurrency = isSupportedMarketplaceCurrency;
+const normalizeMarketplaceCurrency = (value) => (0, exports.isSupportedMarketplaceCurrency)(value)
+    ? value.trim().toUpperCase()
+    : undefined;
+exports.normalizeMarketplaceCurrency = normalizeMarketplaceCurrency;
+const getCurrencyForCountry = (country) => {
+    if (!country)
+        return undefined;
+    return COUNTRY_CURRENCY_MAP[country.trim().toUpperCase()];
+};
+exports.getCurrencyForCountry = getCurrencyForCountry;
+const getRegionFromLocale = (locale) => {
+    if (!locale)
+        return undefined;
+    const normalized = locale.replace('_', '-');
+    const parts = normalized.split('-');
+    return parts.find((part) => /^[A-Z]{2}$/.test(part) || /^[a-z]{2}$/.test(part))?.toUpperCase();
+};
+const getDefaultMarketplaceCurrency = ({ savedCurrency, country, locale, fallbackCurrency = 'EUR', }) => {
+    const saved = (0, exports.normalizeMarketplaceCurrency)(savedCurrency);
+    if (saved)
+        return saved;
+    const countryCurrency = (0, exports.getCurrencyForCountry)(country);
+    if (countryCurrency)
+        return countryCurrency;
+    const localeRegionCurrency = (0, exports.getCurrencyForCountry)(getRegionFromLocale(locale));
+    if (localeRegionCurrency)
+        return localeRegionCurrency;
+    return fallbackCurrency;
+};
+exports.getDefaultMarketplaceCurrency = getDefaultMarketplaceCurrency;
+const roundMarketplaceCurrencyCents = (amountCents, currency) => {
+    const roundedCents = Math.round(amountCents);
+    const step = exports.MARKETPLACE_CURRENCY_ROUNDING_CENTS[currency] ?? 1;
+    if (roundedCents <= 0 || step <= 1)
+        return roundedCents;
+    return Math.max(step, Math.round(roundedCents / step) * step);
+};
+exports.roundMarketplaceCurrencyCents = roundMarketplaceCurrencyCents;
+const convertCurrencyCents = (baseAmountCents, rate, targetCurrency) => {
+    const converted = baseAmountCents * rate;
+    return targetCurrency
+        ? (0, exports.roundMarketplaceCurrencyCents)(converted, targetCurrency)
+        : Math.round(converted);
+};
+exports.convertCurrencyCents = convertCurrencyCents;
+const buildCurrencyConversionResult = (baseAmountCents, rateSnapshot) => ({
+    baseAmountCents,
+    baseCurrency: rateSnapshot.baseCurrency,
+    convertedAmountCents: rateSnapshot.baseCurrency === rateSnapshot.targetCurrency
+        ? baseAmountCents
+        : (0, exports.convertCurrencyCents)(baseAmountCents, rateSnapshot.rate, rateSnapshot.targetCurrency),
+    targetCurrency: rateSnapshot.targetCurrency,
+    rate: rateSnapshot.rate,
+    rateDate: rateSnapshot.rateDate,
+    rateProvider: rateSnapshot.provider,
+});
+exports.buildCurrencyConversionResult = buildCurrencyConversionResult;

package/helpers/dataStructures/trees/index.d.ts

@@ -0,0 +1,12 @@
+import { NodeRow, Table } from './types';
+export declare const roots: <IdType extends string, TableType extends Table<IdType>>(tbl: TableType) => IdType[];
+export declare const childrenOf: <IdType extends string, TableType extends Table<IdType>>(tbl: TableType, parentId: IdType) => IdType[];
+export declare const ancestors: <IdType extends string, TableType extends Table<IdType>>(tbl: TableType, id: IdType) => IdType[];
+export declare const descendants: <IdType extends string, TableType extends Table<IdType>>(tbl: TableType, id: IdType) => IdType[];
+export declare const leafIds: <IdType extends string, TableType extends Table<IdType>>(table: TableType) => IdType[];
+export declare const pathOf: <IdType extends string, TableType extends Table<IdType>>(tbl: TableType, id: IdType) => IdType[];
+export declare function normalizeSelection<IdType extends string, TableType extends Table<IdType>>(tbl: TableType, selectedIds: IdType[] | undefined, options?: {
+    includeDescendants?: boolean;
+}): Set<IdType>;
+export declare function makePredicateForProperty<IdType extends string>(key: keyof NodeRow<IdType>, allowed: Set<IdType>): (row: NodeRow<IdType>) => boolean;
+export declare const breadcrumb: <IdType extends string, TableType extends Table<IdType>>(tbl: TableType, id: IdType, resolve: (k: string) => string, sep?: string) => string;

package/helpers/dataStructures/trees/index.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.breadcrumb = exports.pathOf = exports.leafIds = exports.descendants = exports.ancestors = exports.childrenOf = exports.roots = void 0;
+exports.normalizeSelection = normalizeSelection;
+exports.makePredicateForProperty = makePredicateForProperty;
+const roots = (tbl) => Object.values(tbl)
+    .filter((n) => !n.parentId)
+    .map((n) => n.id);
+exports.roots = roots;
+const childrenOf = (tbl, parentId) => Object.values(tbl)
+    .filter((n) => n.parentId === parentId)
+    .sort((a, b) => (a.order ?? 0) - (b.order ?? 0))
+    .map((n) => n.id);
+exports.childrenOf = childrenOf;
+const ancestors = (tbl, id) => {
+    const out = [];
+    let cur = tbl[id];
+    while (cur?.parentId) {
+        out.unshift(cur.parentId);
+        cur = tbl[cur.parentId];
+    }
+    return out;
+};
+exports.ancestors = ancestors;
+const descendants = (tbl, id) => {
+    const out = [];
+    const stack = [...(0, exports.childrenOf)(tbl, id)];
+    while (stack.length) {
+        const x = stack.pop();
+        out.push(x);
+        stack.push(...(0, exports.childrenOf)(tbl, x));
+    }
+    return out;
+};
+exports.descendants = descendants;
+const leafIds = (table) => {
+    const rows = Object.values(table);
+    const parentIds = new Set(rows.map((row) => row.parentId).filter((pid) => !!pid));
+    return rows.filter((row) => !parentIds.has(row.id)).map((row) => row.id);
+};
+exports.leafIds = leafIds;
+const pathOf = (tbl, id) => [...(0, exports.ancestors)(tbl, id), id];
+exports.pathOf = pathOf;
+// Expand selection (optionally include descendants)
+function normalizeSelection(tbl, selectedIds, options) {
+    const ids = new Set();
+    (selectedIds ?? []).forEach((id) => {
+        ids.add(id);
+        if (options?.includeDescendants) {
+            (0, exports.descendants)(tbl, id).forEach((d) => ids.add(d));
+        }
+    });
+    return ids;
+}
+// Predicate to filter array of entities by property
+function makePredicateForProperty(key, allowed) {
+    return (row) => {
+        if (allowed.size === 0)
+            return true;
+        const val = row[key];
+        if (Array.isArray(val)) {
+            return val.some((x) => typeof x === 'string' && allowed.has(x));
+        }
+        return typeof val === 'string' && allowed.has(val);
+    };
+}
+// Build breadcrumb text (resolved labels joined by separator)
+const breadcrumb = (tbl, id, resolve, sep = ' › ') => (0, exports.pathOf)(tbl, id)
+    .map((x) => resolve(tbl[x].labelKey))
+    .join(sep);
+exports.breadcrumb = breadcrumb;

package/helpers/dataStructures/trees/types.d.ts

@@ -0,0 +1,14 @@
+export interface NodeRow<IdType extends string> {
+    id: IdType;
+    labelKey: string;
+    parentId?: IdType;
+    order?: number;
+    meta?: Record<string, unknown>;
+}
+export type LeafIds<T> = Exclude<keyof T, {
+    [K in keyof T]: T[K] extends {
+        parentId: infer P;
+    } ? P : never;
+}[keyof T]>;
+export declare const defineTable: <IdType extends string, const T extends Record<IdType, NodeRow<IdType>>>(table: T) => T;
+export type Table<IdType extends string, T = NodeRow<IdType>> = Record<IdType, T>;

package/helpers/dataStructures/trees/types.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineTable = void 0;
+const defineTable = (table) => table;
+exports.defineTable = defineTable;

package/helpers/dlinks.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DLinkActions = void 0;
+var DLinkActions;
+(function (DLinkActions) {
+    DLinkActions["JoinGroup"] = "joingroup";
+    DLinkActions["JoinEvent"] = "joinevent";
+    DLinkActions["Group"] = "group";
+    DLinkActions["Event"] = "event";
+    DLinkActions["RollCall"] = "rollcall";
+    DLinkActions["Offer"] = "offer";
+})(DLinkActions || (exports.DLinkActions = DLinkActions = {}));