@futdevpro/fsm-dynamo 1.20.88 → 1.20.93

package/build-esm/_modules/operation-control/_collections/operation-lease.util.js

@@ -0,0 +1,323 @@
+const dyfm_operationHash = /^[0-9a-f]{64}$/u;
+const dyfm_maxOperationTime = 8_640_000_000_000_000;
+const dyfm_commandBaseKeys = ['contractVersion', 'kind', 'operationId', 'requestId', 'scopeHash'];
+const dyfm_recordKeys = [
+    'contractVersion', 'scopeHash', 'operationId', 'state', 'revision', 'fencingToken', 'ownerId',
+    'createdAtMs', 'updatedAtMs', 'heartbeatAtMs', 'leaseExpiresAtMs', 'cancellationRequestedAtMs',
+    'terminalAtMs', 'reason',
+];
+/** Copies plain own data properties without invoking getters or reflecting rejected values. */
+function dyfm_operationData(value) {
+    try {
+        if (typeof value !== 'object' || value === null) {
+            return undefined;
+        }
+        const prototype = Object.getPrototypeOf(value);
+        if (prototype !== Object.prototype && prototype !== null) {
+            return undefined;
+        }
+        const result = Object.create(null);
+        for (const key of Reflect.ownKeys(value)) {
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            if (typeof key !== 'string' || !descriptor?.enumerable || !('value' in descriptor)) {
+                return undefined;
+            }
+            result[key] = descriptor.value;
+        }
+        return result;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Requires an exact schema, including absence of hidden or unknown fields. */
+function dyfm_operationKeys(value, keys) {
+    const actual = Object.keys(value);
+    return actual.length === keys.length && actual.every((key) => keys.includes(key));
+}
+/** Rejects unsafe, negative, fractional and out-of-Date-range epoch milliseconds. */
+function dyfm_operationTime(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 && value <= dyfm_maxOperationTime;
+}
+/** Bounded positive integer used for revisions, live fencing tokens and lease durations. */
+function dyfm_operationPositive(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value > 0;
+}
+/** Validates an opaque identity without converting arbitrary values to strings. */
+function dyfm_operationIdentity(value) {
+    return typeof value === 'string' && dyfm_operationHash.test(value);
+}
+/** Narrows explicit nullable timestamps even in consumers compiled without strictNullChecks. */
+function dyfm_operationOptionalTime(value) {
+    return value === null || dyfm_operationTime(value);
+}
+/** Null represents an unowned state, never a missing or unvalidated owner field. */
+function dyfm_operationOptionalOwner(value) {
+    return value === null || dyfm_operationIdentity(value);
+}
+/** Finite content-free persisted reasons, with explicit null while running. */
+function dyfm_operationReason(value) {
+    return value === null || value === 'abandoned' || value === 'completed'
+        || value === 'failed' || value === 'cancel-requested';
+}
+/** Parses a strict versioned command; time and policy limits belong to the trusted durable store. */
+function dyfm_parseOperationCommand(value) {
+    const data = dyfm_operationData(value);
+    if (!data || data.contractVersion !== 'dyfm-operation-command/1'
+        || !dyfm_operationIdentity(data.scopeHash) || !dyfm_operationIdentity(data.operationId)
+        || !dyfm_operationIdentity(data.requestId)) {
+        return undefined;
+    }
+    let extra;
+    switch (data.kind) {
+        case 'acquire':
+            extra = ['ownerId', 'leaseDurationMs'];
+            break;
+        case 'renew':
+            extra = ['ownerId', 'fencingToken', 'leaseDurationMs'];
+            break;
+        case 'request-cancel':
+            extra = [];
+            break;
+        case 'complete':
+            extra = ['ownerId', 'fencingToken', 'outcome'];
+            break;
+        case 'abandon':
+            extra = ['ownerId', 'fencingToken'];
+            break;
+        default: return undefined;
+    }
+    if (!dyfm_operationKeys(data, [...dyfm_commandBaseKeys, ...extra])) {
+        return undefined;
+    }
+    const identity = {
+        contractVersion: data.contractVersion, scopeHash: data.scopeHash,
+        operationId: data.operationId, requestId: data.requestId,
+    };
+    if (data.kind === 'request-cancel') {
+        return Object.freeze({ ...identity, kind: data.kind });
+    }
+    if (!dyfm_operationIdentity(data.ownerId)) {
+        return undefined;
+    }
+    if (data.kind === 'acquire') {
+        return dyfm_operationPositive(data.leaseDurationMs)
+            ? Object.freeze({ ...identity, kind: data.kind, ownerId: data.ownerId, leaseDurationMs: data.leaseDurationMs })
+            : undefined;
+    }
+    if (!dyfm_operationPositive(data.fencingToken)) {
+        return undefined;
+    }
+    const owned = {
+        ...identity, ownerId: data.ownerId, fencingToken: data.fencingToken,
+    };
+    if (data.kind === 'renew') {
+        return dyfm_operationPositive(data.leaseDurationMs)
+            ? Object.freeze({ ...owned, kind: data.kind, leaseDurationMs: data.leaseDurationMs }) : undefined;
+    }
+    if (data.kind === 'abandon') {
+        return Object.freeze({ ...owned, kind: data.kind });
+    }
+    return data.outcome === 'succeeded' || data.outcome === 'failed'
+        ? Object.freeze({ ...owned, kind: 'complete', outcome: data.outcome }) : undefined;
+}
+/** Validates the entire persisted state, including cross-field temporal and terminal invariants. */
+function dyfm_parseOperationRecord(value) {
+    const data = dyfm_operationData(value);
+    if (!data || !dyfm_operationKeys(data, dyfm_recordKeys) || data.contractVersion !== 'dyfm-operation-record/1'
+        || !dyfm_operationIdentity(data.scopeHash) || !dyfm_operationIdentity(data.operationId)
+        || !dyfm_operationPositive(data.revision)
+        || typeof data.fencingToken !== 'number' || !Number.isSafeInteger(data.fencingToken) || data.fencingToken < 0
+        || data.fencingToken > data.revision
+        || !dyfm_operationTime(data.createdAtMs) || !dyfm_operationTime(data.updatedAtMs)
+        || data.updatedAtMs < data.createdAtMs
+        || !dyfm_operationOptionalOwner(data.ownerId)
+        || !dyfm_operationOptionalTime(data.heartbeatAtMs)
+        || !dyfm_operationOptionalTime(data.leaseExpiresAtMs)
+        || !dyfm_operationOptionalTime(data.cancellationRequestedAtMs)
+        || !dyfm_operationOptionalTime(data.terminalAtMs)
+        || !dyfm_operationReason(data.reason)
+        || (data.state !== 'available' && data.state !== 'running' && data.state !== 'succeeded'
+            && data.state !== 'failed' && data.state !== 'cancelled')) {
+        return undefined;
+    }
+    const record = {
+        contractVersion: data.contractVersion, scopeHash: data.scopeHash, operationId: data.operationId,
+        state: data.state, revision: data.revision, fencingToken: data.fencingToken,
+        ownerId: data.ownerId, createdAtMs: data.createdAtMs, updatedAtMs: data.updatedAtMs,
+        heartbeatAtMs: data.heartbeatAtMs, leaseExpiresAtMs: data.leaseExpiresAtMs,
+        cancellationRequestedAtMs: data.cancellationRequestedAtMs, terminalAtMs: data.terminalAtMs, reason: data.reason,
+    };
+    if (!dyfm_operationNullableTimes(record)) {
+        return undefined;
+    }
+    if (record.state === 'available') {
+        if (record.fencingToken < 1 || record.ownerId !== null || record.heartbeatAtMs !== null
+            || record.leaseExpiresAtMs !== null || record.cancellationRequestedAtMs !== null
+            || record.terminalAtMs !== null || record.reason !== 'abandoned') {
+            return undefined;
+        }
+    }
+    else if (record.state === 'running') {
+        if (!dyfm_operationIdentity(record.ownerId) || record.fencingToken < 1
+            || record.heartbeatAtMs !== record.updatedAtMs || record.leaseExpiresAtMs === null
+            || record.leaseExpiresAtMs <= record.updatedAtMs || record.cancellationRequestedAtMs !== null
+            || record.terminalAtMs !== null || record.reason !== null) {
+            return undefined;
+        }
+    }
+    else if (!dyfm_operationTerminalValid(record)) {
+        return undefined;
+    }
+    return Object.freeze({ ...record });
+}
+/** All non-null historical timestamps must fall inside the record's lifetime. */
+function dyfm_operationNullableTimes(record) {
+    for (const time of [record.heartbeatAtMs, record.cancellationRequestedAtMs, record.terminalAtMs]) {
+        if (time !== null && (!dyfm_operationTime(time) || time < record.createdAtMs || time > record.updatedAtMs)) {
+            return false;
+        }
+    }
+    return record.leaseExpiresAtMs === null || dyfm_operationTime(record.leaseExpiresAtMs);
+}
+/** A cancelled tombstone may predate acquisition or follow an abandoned owner. */
+function dyfm_operationTerminalValid(record) {
+    if (record.terminalAtMs !== record.updatedAtMs || record.leaseExpiresAtMs !== null) {
+        return false;
+    }
+    if (record.state === 'cancelled') {
+        return record.reason === 'cancel-requested' && record.cancellationRequestedAtMs === record.terminalAtMs
+            && ((record.ownerId === null && record.heartbeatAtMs === null)
+                || (dyfm_operationIdentity(record.ownerId) && record.fencingToken > 0 && record.heartbeatAtMs !== null));
+    }
+    return (record.state === 'succeeded' || record.state === 'failed')
+        && record.reason === (record.state === 'succeeded' ? 'completed' : 'failed')
+        && record.cancellationRequestedAtMs === null && dyfm_operationIdentity(record.ownerId)
+        && record.fencingToken > 0 && record.heartbeatAtMs !== null;
+}
+/** Constructs a detached, immutable content-free proposal. */
+function dyfm_operationDecision(code, current, next) {
+    return Object.freeze({
+        contractVersion: 'dyfm-operation-decision/1',
+        accepted: next !== undefined || code === 'cancelled',
+        code: code,
+        writeRequired: next !== undefined,
+        expectedRevision: current?.revision ?? null,
+        record: next ? Object.freeze(next) : current,
+    });
+}
+/** Builds an initial acquired state or a cancel-before-acquire tombstone without creating a runnable draft. */
+function dyfm_operationInitial(command, nowMs) {
+    const acquiring = command.kind === 'acquire';
+    return {
+        contractVersion: 'dyfm-operation-record/1', scopeHash: command.scopeHash, operationId: command.operationId,
+        state: acquiring ? 'running' : 'cancelled', revision: 1, fencingToken: acquiring ? 1 : 0,
+        ownerId: command.kind === 'acquire' ? command.ownerId : null,
+        createdAtMs: nowMs, updatedAtMs: nowMs, heartbeatAtMs: acquiring ? nowMs : null,
+        leaseExpiresAtMs: command.kind === 'acquire' ? nowMs + command.leaseDurationMs : null,
+        cancellationRequestedAtMs: acquiring ? null : nowMs, terminalAtMs: acquiring ? null : nowMs,
+        reason: acquiring ? null : 'cancel-requested',
+    };
+}
+/**
+ * Pure lease/fence transition proposal; performs no I/O, dispatch, retries or clock reads.
+ * nowMs MUST be authoritative store time (never caller/browser time). The store must recheck a live lease
+ * at its atomic write boundary; evaluating this function alone cannot prove distributed ownership.
+ */
+function dyfm_planOperationTransition(currentValue, commandValue, nowMs) {
+    const command = dyfm_parseOperationCommand(commandValue);
+    if (!command) {
+        return dyfm_operationDecision('invalid-command', null);
+    }
+    const current = currentValue === null
+        ? null : dyfm_parseOperationRecord(currentValue) ?? null;
+    if (currentValue !== null && current === null) {
+        return dyfm_operationDecision('invalid-record', null);
+    }
+    if (current && (current.scopeHash !== command.scopeHash || current.operationId !== command.operationId)) {
+        return dyfm_operationDecision('identity-mismatch', null);
+    }
+    if (!dyfm_operationTime(nowMs)) {
+        return dyfm_operationDecision('invalid-clock', current);
+    }
+    if (current && nowMs < current.updatedAtMs) {
+        return dyfm_operationDecision('clock-regressed', current);
+    }
+    if (typeof current?.terminalAtMs === 'number') {
+        return dyfm_operationDecision(current.state === 'cancelled' && command.kind === 'request-cancel' ? 'cancelled' : 'already-terminal', current);
+    }
+    if ((command.kind === 'acquire' || command.kind === 'renew')
+        && !dyfm_operationTime(nowMs + command.leaseDurationMs)) {
+        return dyfm_operationDecision('lease-time-overflow', current);
+    }
+    if (current?.revision === Number.MAX_SAFE_INTEGER) {
+        return dyfm_operationDecision('counter-exhausted', current);
+    }
+    if (current === null) {
+        return command.kind === 'acquire' || command.kind === 'request-cancel'
+            ? dyfm_operationDecision(command.kind === 'acquire' ? 'acquired' : 'cancelled', null, dyfm_operationInitial(command, nowMs))
+            : dyfm_operationDecision('not-found', null);
+    }
+    return dyfm_operationExisting(current, command, nowMs);
+}
+/** Plans a single valid nonterminal record transition; expiry is exclusive (now == expiry is too late). */
+function dyfm_operationExisting(current, command, nowMs) {
+    const next = { ...current, revision: current.revision + 1, updatedAtMs: nowMs };
+    if (command.kind === 'request-cancel') {
+        return dyfm_operationDecision('cancelled', current, {
+            ...next, state: 'cancelled', reason: 'cancel-requested', terminalAtMs: nowMs,
+            cancellationRequestedAtMs: nowMs, leaseExpiresAtMs: null,
+        });
+    }
+    if (command.kind === 'acquire') {
+        if (current.state === 'running' && current.leaseExpiresAtMs > nowMs) {
+            return dyfm_operationDecision('lease-held', current);
+        }
+        if (current.fencingToken === Number.MAX_SAFE_INTEGER) {
+            return dyfm_operationDecision('counter-exhausted', current);
+        }
+        return dyfm_operationDecision('acquired', current, {
+            ...next, state: 'running', fencingToken: current.fencingToken + 1, ownerId: command.ownerId,
+            heartbeatAtMs: nowMs, leaseExpiresAtMs: nowMs + command.leaseDurationMs, reason: null,
+        });
+    }
+    if (current.state !== 'running') {
+        return dyfm_operationDecision('not-running', current);
+    }
+    if (current.ownerId !== command.ownerId || current.fencingToken !== command.fencingToken) {
+        return dyfm_operationDecision('owner-mismatch', current);
+    }
+    if (current.leaseExpiresAtMs <= nowMs) {
+        return dyfm_operationDecision('lease-expired', current);
+    }
+    if (command.kind === 'renew') {
+        return dyfm_operationDecision('renewed', current, {
+            ...next, heartbeatAtMs: nowMs,
+            leaseExpiresAtMs: Math.max(current.leaseExpiresAtMs, nowMs + command.leaseDurationMs),
+        });
+    }
+    if (command.kind === 'abandon') {
+        return dyfm_operationDecision('abandoned', current, {
+            ...next, state: 'available', ownerId: null, heartbeatAtMs: null, leaseExpiresAtMs: null, reason: 'abandoned',
+        });
+    }
+    return dyfm_operationDecision('completed', current, {
+        ...next, state: command.outcome, reason: command.outcome === 'succeeded' ? 'completed' : 'failed',
+        terminalAtMs: nowMs, leaseExpiresAtMs: null,
+    });
+}
+/** Strict, deterministic operation-control contract; durability belongs to the atomic NTS store. */
+export class DyFM_OperationLease_Util {
+    /** Copies a valid exact command without invoking accessors or retaining caller objects. */
+    static parseCommand(value) {
+        return dyfm_parseOperationCommand(value);
+    }
+    /** Copies a valid record, checking all state-specific invariants. */
+    static parseRecord(value) {
+        return dyfm_parseOperationRecord(value);
+    }
+    /** Proposes a transition at authoritative store time; never a durable receipt or dispatch permission. */
+    static planTransition(current, command, nowMs) {
+        return dyfm_planOperationTransition(current, command, nowMs);
+    }
+}

package/build-esm/_modules/operation-control/_enums/operation-decision-code.type-enum.js

@@ -0,0 +1,22 @@
+/** Stable content-free decision vocabulary shared across stores and consumers. */
+export var DyFM_OperationDecisionCode_Type;
+(function (DyFM_OperationDecisionCode_Type) {
+    DyFM_OperationDecisionCode_Type["acquired"] = "acquired";
+    DyFM_OperationDecisionCode_Type["renewed"] = "renewed";
+    DyFM_OperationDecisionCode_Type["cancelled"] = "cancelled";
+    DyFM_OperationDecisionCode_Type["completed"] = "completed";
+    DyFM_OperationDecisionCode_Type["abandoned"] = "abandoned";
+    DyFM_OperationDecisionCode_Type["alreadyTerminal"] = "already-terminal";
+    DyFM_OperationDecisionCode_Type["leaseHeld"] = "lease-held";
+    DyFM_OperationDecisionCode_Type["leaseExpired"] = "lease-expired";
+    DyFM_OperationDecisionCode_Type["ownerMismatch"] = "owner-mismatch";
+    DyFM_OperationDecisionCode_Type["notRunning"] = "not-running";
+    DyFM_OperationDecisionCode_Type["notFound"] = "not-found";
+    DyFM_OperationDecisionCode_Type["invalidCommand"] = "invalid-command";
+    DyFM_OperationDecisionCode_Type["invalidRecord"] = "invalid-record";
+    DyFM_OperationDecisionCode_Type["identityMismatch"] = "identity-mismatch";
+    DyFM_OperationDecisionCode_Type["invalidClock"] = "invalid-clock";
+    DyFM_OperationDecisionCode_Type["clockRegressed"] = "clock-regressed";
+    DyFM_OperationDecisionCode_Type["counterExhausted"] = "counter-exhausted";
+    DyFM_OperationDecisionCode_Type["leaseTimeOverflow"] = "lease-time-overflow";
+})(DyFM_OperationDecisionCode_Type || (DyFM_OperationDecisionCode_Type = {}));

package/build-esm/_modules/operation-control/_enums/operation-state.type-enum.js

@@ -0,0 +1,9 @@
+/** Closed durable lifecycle. A cancelled identity must never become runnable again. */
+export var DyFM_OperationState_Type;
+(function (DyFM_OperationState_Type) {
+    DyFM_OperationState_Type["available"] = "available";
+    DyFM_OperationState_Type["running"] = "running";
+    DyFM_OperationState_Type["succeeded"] = "succeeded";
+    DyFM_OperationState_Type["failed"] = "failed";
+    DyFM_OperationState_Type["cancelled"] = "cancelled";
+})(DyFM_OperationState_Type || (DyFM_OperationState_Type = {}));

package/build-esm/_modules/operation-control/_models/operation-lease.interface.js

@@ -0,0 +1 @@
+export {};

package/build-esm/_modules/operation-control/index.js

@@ -0,0 +1,4 @@
+export * from './_collections/operation-lease.util';
+export * from './_enums/operation-decision-code.type-enum';
+export * from './_enums/operation-state.type-enum';
+export * from './_models/operation-lease.interface';

package/build-esm/_modules/pipe/_collections/pip-transforms.const.js

@@ -0,0 +1,32 @@
+import { DyFM_country_pipeTransform } from './utils/pip-country-pipe.util';
+import { DyFM_custom_pipeTransform } from './utils/pip-custom-pipe.util';
+import { DyFM_division_pipeTransform } from './utils/pip-division-pipe.util';
+import { DyFM_list_pipeTransform } from './utils/pip-list-pipe.util';
+import { DyFM_multiPipe_pipeTransform } from './utils/pip-multi-pipe-pipe.util';
+import { DyFM_objKey_pipeTransform } from './utils/pip-obj-key-pipe.util';
+import { DyFM_range_pipeTransform } from './utils/pip-range-pipe.util';
+import { DyFM_region_pipeTransform } from './utils/pip-region-pipe.util';
+import { DyFM_replace_pipeTransform } from './utils/pip-replace-pipe.util';
+import { DyFM_slider_pipeTransform } from './utils/pip-slider-pipe.util';
+import { DyFM_smartReplace_pipeTransform } from './utils/pip-smart-replace-pipe.util';
+import { DyFM_Pipe } from '../_enums/pip.enum';
+import { DyFM_json_pipeTransform } from './utils/pip-json-pipe.util';
+/**
+ * This is the main object that contains all the pipe transforms
+ *
+ * @see {@link DyFM_PipeTransforms}
+ */
+export const DyFM_pipeTransforms = {
+    [DyFM_Pipe.country]: DyFM_country_pipeTransform,
+    [DyFM_Pipe.custom]: DyFM_custom_pipeTransform,
+    [DyFM_Pipe.division]: DyFM_division_pipeTransform,
+    [DyFM_Pipe.json]: DyFM_json_pipeTransform,
+    [DyFM_Pipe.list]: DyFM_list_pipeTransform,
+    [DyFM_Pipe.multiPipe]: DyFM_multiPipe_pipeTransform,
+    [DyFM_Pipe.objKey]: DyFM_objKey_pipeTransform,
+    [DyFM_Pipe.range]: DyFM_range_pipeTransform,
+    [DyFM_Pipe.region]: DyFM_region_pipeTransform,
+    [DyFM_Pipe.replace]: DyFM_replace_pipeTransform,
+    [DyFM_Pipe.slider]: DyFM_slider_pipeTransform,
+    [DyFM_Pipe.smartReplace]: DyFM_smartReplace_pipeTransform,
+};

package/build-esm/_modules/pipe/_collections/utils/pip-country-pipe.util.js

@@ -0,0 +1,29 @@
+import { DyFM_countryISOs } from '../../../location/_collections/loc-country-isos.const';
+/**
+ *
+ * @param countryISO - country ISO code
+ * @returns country name
+ *
+ * @example
+ *
+ * ```html
+ * {{ 'US' | country }}
+ * ```
+ * will return `United States`
+ *
+ *
+ * ```html
+ * {{ 'DE' | country }}
+ * ```
+ * will return `Germany`
+ *
+ *
+ * ```html
+ * {{ 'ZZ' | country }}
+ * ```
+ * will return `ZZ`
+ */
+export function DyFM_country_pipeTransform(countryISO) {
+    const result = DyFM_countryISOs.find((iso) => iso.iso2 === countryISO)?.name;
+    return result ?? countryISO;
+}

package/build-esm/_modules/pipe/_collections/utils/pip-custom-pipe.util.js

@@ -0,0 +1,22 @@
+/**
+ * This is a helper function to create custom pipes
+ * you can use it to create custom pipes within the same component
+ *
+ * @example
+ *
+ * ```html
+ * {{ 'Hello' | custom: (value) => value.toUpperCase() }}
+ * ```
+ * will return `HELLO`
+ *
+ *
+ * ```html
+ * {{ 'Hello' | custom: (value, ...args) => value.toUpperCase() }}
+ * ```
+ * will return `HELLO`
+ *
+ *
+ */
+export function DyFM_custom_pipeTransform(value, customTransform, ...args) {
+    return customTransform(value, ...args);
+}

package/build-esm/_modules/pipe/_collections/utils/pip-division-pipe.util.js

@@ -0,0 +1,21 @@
+import { DyFM_countryDivisions } from '../../../location/_collections/loc-country-divisions.const';
+/**
+ * This pipe will return the division name for a given division code and country ISO
+ *
+ * @example
+ *
+ * ```html
+ * {{ 'US-CA' | division: 'US' }}
+ * ```
+ * will return `California`
+ *
+ * ```html
+ * {{ 'DE-BE' | division: 'DE' }}
+ * ```
+ * will return `Berlin`
+ *
+ */
+export function DyFM_division_pipeTransform(divisionCode, countryISO) {
+    const result = DyFM_countryDivisions?.find((d) => d?.code === divisionCode && d?.iso === countryISO)?.name;
+    return result ?? divisionCode;
+}

package/build-esm/_modules/pipe/_collections/utils/pip-json-pipe.util.js

@@ -0,0 +1,18 @@
+/**
+ * This pipe will return a string of the object values separated by a comma
+ *
+ * @example
+ *
+ * ```html
+ * {{ { a: 1, b: 2, c: 3 } | json }}
+ * ```
+ * will return `{
+ *   "a":1,
+ *   "b":2,
+ *   "c":3
+ * }`
+ *
+ */
+export function DyFM_json_pipeTransform(value, depth = 2) {
+    return JSON.stringify(value, null, depth);
+}

package/build-esm/_modules/pipe/_collections/utils/pip-list-pipe.util.js

@@ -0,0 +1,19 @@
+/**
+ * This pipe will return a string of the array values separated by a comma
+ *
+ * @example
+ *
+ * ```html
+ * {{ [1, 2, 3] | list }}
+ * ```
+ * will return `1, 2, 3`
+ *
+ * ```html
+ * {{ ['a', 'b', 'c'] | list }}
+ * ```
+ * will return `a, b, c`
+ *
+ */
+export function DyFM_list_pipeTransform(value) {
+    return value.toString().replace(/,/g, ', ');
+}