@genesislcap/foundation-forms 15.50.2 → 15.50.3-holiday-picker.2

package/dist/esm/jsonforms/renderers/ValueDateControlRenderer.js

@@ -0,0 +1,275 @@
+import { mapStateToControlProps, rankWith, Resolve, toDataPath } from '@jsonforms/core';
+import { html } from '@microsoft/fast-element';
+import { optionIs } from '../testers/optionIs';
+import { controlWrapperTemplate } from './ControlWrapperRenderer';
+import { toDateControlValue, toIsoDateValue } from './date-value-format';
+import { rendererOptionsOf, rootDataOf, siblingStringOf } from './renderer-data';
+import { VALUE_DATE_CONTROL_RANK } from './RenderersRanks';
+const SOFR = {
+    spotLag: 'T+2',
+    dayRollConvention: 'modifiedFollowing',
+    currency: 'USD',
+};
+const SONIA = {
+    spotLag: 'T+0',
+    dayRollConvention: 'modifiedFollowing',
+    currency: 'GBP',
+};
+const ESTR = {
+    spotLag: 'T+1',
+    dayRollConvention: 'modifiedFollowing',
+    currency: 'EUR',
+};
+const TONA = {
+    spotLag: 'T+2',
+    dayRollConvention: 'modifiedFollowing',
+    currency: 'JPY',
+};
+const t2 = (currency) => ({
+    spotLag: 'T+2',
+    dayRollConvention: 'modifiedFollowing',
+    currency,
+});
+/**
+ * Default settlement convention per overnight benchmark index, applied when the control's
+ * `options.indexField` sibling carries one of these codes: a short name (`SOFR`) or its FpML
+ * `floatingRateIndexScheme` code (`USD-SOFR`, checked against scheme 3-14).
+ * @public
+ */
+export const DEFAULT_INDEX_CONVENTIONS = {
+    SOFR,
+    SONIA,
+    ESTR,
+    TONA,
+    'USD-SOFR': SOFR,
+    'USD-SOFR ICE Term': SOFR,
+    'GBP-SONIA': SONIA,
+    'EUR-EuroSTR': ESTR,
+    'JPY-TONA': TONA,
+    'CHF-SARON': t2('CHF'),
+    'DKK-DESTR': t2('DKK'),
+    'NOK-NOWA': t2('NOK'),
+    'SEK-SWESTR': t2('SEK'),
+    'PLN-WIRON': t2('PLN'),
+    'SGD-SORA': t2('SGD'),
+    'TRY-TLREF': t2('TRY'),
+};
+// `<foundation-value-date>`'s own defaults.
+const DEFAULT_SPOT_LAG = 'HOST_T+2';
+const DEFAULT_DAY_ROLL_CONVENTION = 'modifiedFollowing';
+function optionsOf(x) {
+    return rendererOptionsOf(x);
+}
+function baseCurrencyOf(x) {
+    var _a, _b;
+    const options = optionsOf(x);
+    return (_b = siblingStringOf(x, (_a = options.baseCurrencyField) !== null && _a !== void 0 ? _a : 'BASE_CURRENCY')) !== null && _b !== void 0 ? _b : options.baseCurrency;
+}
+function quoteCurrencyOf(x) {
+    var _a, _b;
+    const options = optionsOf(x);
+    return ((_b = siblingStringOf(x, (_a = options.quoteCurrencyField) !== null && _a !== void 0 ? _a : 'QUOTE_CURRENCY')) !== null && _b !== void 0 ? _b : options.quoteCurrency);
+}
+function indexConventionOf(x) {
+    var _a;
+    const index = siblingStringOf(x, (_a = optionsOf(x).indexField) !== null && _a !== void 0 ? _a : 'INDEX');
+    return index ? DEFAULT_INDEX_CONVENTIONS[index] : undefined;
+}
+/**
+ * The conventions this control locks: a recognised index's, else the fixed
+ * `spotLag`/`dayRollConvention` options; `undefined` leaves them to the user.
+ */
+function lockedConventionOf(x) {
+    const index = indexConventionOf(x);
+    if (index) {
+        return index;
+    }
+    const { spotLag, dayRollConvention } = optionsOf(x);
+    return spotLag || dayRollConvention
+        ? {
+            spotLag: spotLag !== null && spotLag !== void 0 ? spotLag : DEFAULT_SPOT_LAG,
+            dayRollConvention: dayRollConvention !== null && dayRollConvention !== void 0 ? dayRollConvention : DEFAULT_DAY_ROLL_CONVENTION,
+        }
+        : undefined;
+}
+/** The widest spot lag `<foundation-value-date>` offers, in business days. */
+const MAX_SPOT_LAG_DAYS = 2;
+/** A spot lag in business days (`T+N` is `N`); `HOST_T+2` counts two. */
+export function spotLagDaysOf(spotLag) {
+    return spotLag === 'HOST_T+2' ? MAX_SPOT_LAG_DAYS : Number(spotLag.slice('T+'.length));
+}
+/**
+ * The spot lag for a stored day count, capped at `T+2`; `undefined` for an empty or invalid value.
+ * @internal
+ */
+export function spotLagOfDays(days) {
+    const n = typeof days === 'string' && days.trim() ? Number(days) : days;
+    if (typeof n !== 'number' || !Number.isInteger(n) || n < 0) {
+        return undefined;
+    }
+    return `T+${Math.min(n, MAX_SPOT_LAG_DAYS)}`;
+}
+/** The `spotLagDaysScope` field's data path, or `undefined` without one. */
+function spotLagDaysPathOf(x) {
+    const scope = optionsOf(x).spotLagDaysScope;
+    return scope ? toDataPath(scope) : undefined;
+}
+/** The raw value of the `spotLagDaysScope` field. */
+function storedSpotLagDaysOf(x) {
+    const path = spotLagDaysPathOf(x);
+    return path ? Resolve.data(rootDataOf(x), path) : undefined;
+}
+/** The conventions the user last picked, echoed back on re-render. */
+const userConventionsState = new WeakMap();
+/**
+ * Locked conventions win; otherwise the user's own choice; otherwise the `spotLagDaysScope`
+ * field's lag; otherwise the widget's defaults.
+ * @internal
+ */
+export function conventionsOf(x) {
+    var _a, _b, _c;
+    return ((_b = (_a = lockedConventionOf(x)) !== null && _a !== void 0 ? _a : userConventionsState.get(x)) !== null && _b !== void 0 ? _b : {
+        spotLag: (_c = spotLagOfDays(storedSpotLagDaysOf(x))) !== null && _c !== void 0 ? _c : DEFAULT_SPOT_LAG,
+        dayRollConvention: DEFAULT_DAY_ROLL_CONVENTION,
+    });
+}
+/**
+ * Keeps the user's choice, and writes a changed spot lag to the `spotLagDaysScope` field. An
+ * unchanged lag leaves the field alone, so a stored offset above 2 survives a day-roll edit.
+ * @internal
+ */
+export function handleConventionsChanged(x, event) {
+    const detail = event.detail;
+    userConventionsState.set(x, detail);
+    const path = spotLagDaysPathOf(x);
+    if (path && spotLagOfDays(storedSpotLagDaysOf(x)) !== detail.spotLag) {
+        x.control.handleChange(path, spotLagDaysOf(detail.spotLag));
+    }
+}
+/** The `tradeDateField` sibling's value as ISO `YYYY-MM-DD`; `undefined` counts from today. */
+function tradeDateOf(x) {
+    const field = optionsOf(x).tradeDateField;
+    return field ? toIsoDateValue(rootDataOf(x)[field]) : undefined;
+}
+/** The element's last `targetInput` (e.g. a typed tenor), echoed back on re-render. */
+const targetInputState = new WeakMap();
+/**
+ * The element's last `targetInput`, else a first-render seed: `SPOT` with `tradeDateField` (so it
+ * follows the trade date), otherwise the stored value as ISO `YYYY-MM-DD` so it round-trips.
+ */
+function targetInputOf(x) {
+    const cached = targetInputState.get(x);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const seed = optionsOf(x).tradeDateField ? 'SPOT' : toIsoDateValue(x.control.data) || 'SPOT';
+    targetInputState.set(x, seed);
+    return seed;
+}
+/** The base, quote and index currencies that drive `holidayCurrencies`, in that order. */
+function drivingCurrenciesOf(x) {
+    var _a;
+    return [baseCurrencyOf(x), quoteCurrencyOf(x), (_a = indexConventionOf(x)) === null || _a === void 0 ? void 0 : _a.currency];
+}
+/** Identifies the driving currencies, so a cached selection is dropped when they change. */
+function currencySignatureOf(currencies) {
+    return currencies.map((code) => code !== null && code !== void 0 ? code : '').join('|');
+}
+/**
+ * `holidayCurrencies` derived from the pair/index, or the user's own selection, keyed by the
+ * signature it belongs to; a pair/index change invalidates it.
+ */
+const holidayCurrenciesState = new WeakMap();
+function holidayCurrenciesOf(x) {
+    const driving = drivingCurrenciesOf(x);
+    const signature = currencySignatureOf(driving);
+    const cached = holidayCurrenciesState.get(x);
+    if (cached && cached.signature === signature) {
+        return cached.currencies;
+    }
+    const currencies = Array.from(new Set(driving.filter((code) => !!code)));
+    holidayCurrenciesState.set(x, { signature, currencies });
+    return currencies;
+}
+/** @internal */
+export function handleValueDateChanged(x, event) {
+    var _a;
+    const detail = event.detail;
+    const targetInput = (_a = event.target) === null || _a === void 0 ? void 0 : _a.targetInput;
+    if (targetInput !== undefined) {
+        targetInputState.set(x, targetInput);
+    }
+    x.onBlur();
+    const { valueFormat = 'iso', unadjustedDateScope } = optionsOf(x);
+    x.control.handleChange(x.control.path, 
+    // `undefined` (the target no longer resolves) clears the control.
+    toDateControlValue(detail.deliveryDateValue, valueFormat));
+    if (unadjustedDateScope) {
+        x.control.handleChange(toDataPath(unadjustedDateScope), toDateControlValue(detail.targetDateValue, valueFormat));
+    }
+    const spotLagDaysPath = spotLagDaysPathOf(x);
+    if (spotLagDaysPath && spotLagOfDays(storedSpotLagDaysOf(x)) === undefined) {
+        x.control.handleChange(spotLagDaysPath, spotLagDaysOf(detail.spotLag));
+    }
+}
+/** Captures the user's holiday-calendar selection for `holidayCurrenciesOf` to echo back. */
+function handleHolidayCurrenciesChanged(x, event) {
+    const currencies = event.detail;
+    holidayCurrenciesState.set(x, {
+        signature: currencySignatureOf(drivingCurrenciesOf(x)),
+        currencies,
+    });
+}
+/**
+ * Renders a `<foundation-value-date>` bound to sibling fields (currency pair, index, trade date)
+ * via `options`, and writes the resolved delivery date back as this control's value - plus,
+ * optionally, the unadjusted date (`unadjustedDateScope`) and the spot lag in days
+ * (`spotLagDaysScope`). A read-only control shows the date with its conventions locked.
+ *
+ * Every binding re-pushes on each form-wide re-render, so values the user can change in the
+ * widget are cached per renderer and echoed back instead of being reset.
+ * @public
+ */
+export const ValueDateControlRendererTemplate = (prefix = 'rapid') => html `
+  <template>
+    ${controlWrapperTemplate({
+    prefix,
+    innerTemplate: html `
+        <${prefix}-value-date
+          id=${(x) => x.control.path}
+          style="${(x) => (x.control.enabled ? '' : 'pointer-events: none; opacity: 0.6;')}"
+          aria-disabled="${(x) => (x.control.enabled ? 'false' : 'true')}"
+          data-test-id=${(x) => x.control.path}
+          base-currency="${(x) => baseCurrencyOf(x)}"
+          quote-currency="${(x) => quoteCurrencyOf(x)}"
+          ?holiday-calendars=${(x) => !!optionsOf(x).holidayCalendars}
+          :holidayCurrencies=${(x) => holidayCurrenciesOf(x)}
+          :targetInput=${(x) => targetInputOf(x)}
+          trade-date="${(x) => tradeDateOf(x)}"
+          :spotLag=${(x) => conventionsOf(x).spotLag}
+          :dayRollConvention=${(x) => conventionsOf(x).dayRollConvention}
+          ?lock-conventions=${(x) => !!lockedConventionOf(x) || !x.control.enabled}
+          @value-date-changed=${(x, c) => handleValueDateChanged(x, c.event)}
+          @holiday-currencies-changed=${(x, c) => handleHolidayCurrenciesChanged(x, c.event)}
+          @conventions-changed=${(x, c) => handleConventionsChanged(x, c.event)}
+        ></${prefix}-value-date>
+      `,
+})}
+  </template>
+`;
+/**
+ * Renderer entry for a value-date control. Opt in per form via `additionalRenderers`:
+ * ```ts
+ * import { ValueDateControlRendererEntry } from '@genesislcap/foundation-forms';
+ * form.additionalRenderers = [ValueDateControlRendererEntry];
+ * ```
+ * and mark the field with `options: { valueDate: true, baseCurrencyField: 'BASE_CCY', ... }`.
+ * @public
+ */
+export const ValueDateControlRendererEntry = {
+    renderer: html `
+    ${(x) => ValueDateControlRendererTemplate(x.prefix)}
+  `,
+    tester: rankWith(VALUE_DATE_CONTROL_RANK, optionIs('valueDate')),
+    mapper: mapStateToControlProps,
+};

package/dist/esm/jsonforms/renderers/date-value-format.js

@@ -0,0 +1,70 @@
+const ISO_DATE = /^(\d{4})-(\d{2})-(\d{2})$/;
+/** The date picker's internal `value` wire format, `MM-DD-YYYY` (`DATE_PICKER_VALUE_FORMAT`). */
+const PICKER_WIRE_VALUE = /^(\d{2})-(\d{2})-(\d{4})$/;
+const pad = (n) => n.toString().padStart(2, '0');
+/**
+ * Parses a stored date control value — an ISO `YYYY-MM-DD` string or UTC-midnight epoch
+ * milliseconds — into its calendar parts. Returns `undefined` for anything else.
+ * @internal
+ */
+export function parseDateValue(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        const date = new Date(value);
+        return {
+            year: date.getUTCFullYear(),
+            month: date.getUTCMonth() + 1,
+            day: date.getUTCDate(),
+        };
+    }
+    const match = typeof value === 'string' ? ISO_DATE.exec(value) : null;
+    return match
+        ? { year: Number(match[1]), month: Number(match[2]), day: Number(match[3]) }
+        : undefined;
+}
+/**
+ * Serialises calendar parts as an ISO `YYYY-MM-DD` string or UTC-midnight epoch milliseconds.
+ * @internal
+ */
+export function formatDateValue(parts, valueFormat) {
+    return valueFormat === 'epoch'
+        ? Date.UTC(parts.year, parts.month - 1, parts.day)
+        : `${parts.year}-${pad(parts.month)}-${pad(parts.day)}`;
+}
+/**
+ * Converts a date control value (ISO `YYYY-MM-DD` or UTC-midnight epoch milliseconds) into
+ * `valueFormat`, or `undefined` when it isn't a date (which clears the control).
+ * @internal
+ */
+export function toDateControlValue(value, valueFormat) {
+    const parts = parseDateValue(value);
+    return parts ? formatDateValue(parts, valueFormat) : undefined;
+}
+/**
+ * Normalises a date control value to ISO `YYYY-MM-DD`, or `undefined` when it isn't a date.
+ * @internal
+ */
+export function toIsoDateValue(value) {
+    return toDateControlValue(value, 'iso');
+}
+/**
+ * Converts a stored date control value (either storage format) into the picker's `MM-DD-YYYY`
+ * wire value, or `''` when it isn't a date.
+ * @internal
+ */
+export function toPickerWireValue(value) {
+    const parts = parseDateValue(value);
+    return parts ? `${pad(parts.month)}-${pad(parts.day)}-${parts.year}` : '';
+}
+/**
+ * Converts the picker's `value-changed` detail into a storage format; the inverse of
+ * `toPickerWireValue`.
+ * @internal
+ */
+export function fromPickerWireValue(value, valueFormat) {
+    const match = value ? PICKER_WIRE_VALUE.exec(value) : null;
+    if (!match) {
+        return undefined;
+    }
+    const [, month, day, year] = match;
+    return formatDateValue({ year: Number(year), month: Number(month), day: Number(day) }, valueFormat);
+}

package/dist/esm/jsonforms/renderers/renderer-data.js

@@ -0,0 +1,36 @@
+/** A control's `uischema.options`, typed for its renderer. */
+export function rendererOptionsOf(x) {
+    var _a, _b;
+    return ((_b = (_a = x.control.uischema) === null || _a === void 0 ? void 0 : _a.options) !== null && _b !== void 0 ? _b : {});
+}
+/**
+ * The whole form's data, not just this control's, so a control nested anywhere (including in
+ * array rows) can read top-level sibling fields such as a trade currency or start date.
+ */
+export function rootDataOf(x) {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = x.jsonforms) === null || _a === void 0 ? void 0 : _a.core) === null || _b === void 0 ? void 0 : _b.data) !== null && _c !== void 0 ? _c : {};
+}
+/** A top-level sibling field's value when it's a non-empty string, else `undefined`. */
+export function siblingStringOf(x, field) {
+    if (!field) {
+        return undefined;
+    }
+    const value = rootDataOf(x)[field];
+    return typeof value === 'string' && value ? value : undefined;
+}
+/**
+ * Calendar codes from a fixed list plus a top-level sibling field, which may hold an array or a
+ * string separated by `;` (as Genesis calendar fields store them), commas or spaces. Returned
+ * space-separated, deduped, for a date-picker code attribute; `undefined` when there are none.
+ */
+export function calendarCodesOf(x, fixed, field) {
+    const value = field ? rootDataOf(x)[field] : undefined;
+    const fromField = Array.isArray(value)
+        ? value.filter((code) => typeof code === 'string')
+        : typeof value === 'string'
+            ? value.split(/[\s,;]+/)
+            : [];
+    const codes = Array.from(new Set([...(fixed !== null && fixed !== void 0 ? fixed : []), ...fromField].map((code) => code.trim()).filter(Boolean)));
+    return codes.length ? codes.join(' ') : undefined;
+}

package/dist/esm/utils/validation.js

@@ -1,3 +1,4 @@
+import { toIsoDateValue } from '../jsonforms/renderers/date-value-format';
 /**
  * Ensures the value of the current field (the one the validator is on) matches the one of the target field.
  * @param target - any other field
@@ -23,6 +24,44 @@ export const mustMatch = (target) => {
         ];
     };
 };
+const dateOrderValidator = (target, violates, message) => (data, path) => {
+    if (!(path === null || path === void 0 ? void 0 : path.length) || !(target === null || target === void 0 ? void 0 : target.length) || !data)
+        return [];
+    // ISO `YYYY-MM-DD` strings compare chronologically; either field may hold ISO or epoch.
+    const value = toIsoDateValue(data === null || data === void 0 ? void 0 : data[path]);
+    const targetValue = toIsoDateValue(data === null || data === void 0 ? void 0 : data[target]);
+    if (!value || !targetValue || !violates(value, targetValue))
+        return [];
+    return [
+        {
+            instancePath: `/${path}`,
+            message,
+            schemaPath: '',
+            keyword: '',
+            params: {},
+        },
+    ];
+};
+/**
+ * Ensures the date in the current field (the one the validator is on) is on or after the date in
+ * the target field, e.g. an end date that can't be before its start date. Either field may hold
+ * an ISO `YYYY-MM-DD` string or epoch milliseconds; no error while either is empty.
+ * @param target - the other date field, e.g. `'START_DATE'`
+ * @param message - the error shown on the current field; defaults to `Must not be before <target>`
+ * @returns a validator function that will be run by the smart form during the client-side validation stage
+ * @public
+ */
+export const mustBeOnOrAfter = (target, message = `Must not be before ${target}`) => dateOrderValidator(target, (value, targetValue) => value < targetValue, message);
+/**
+ * Ensures the date in the current field (the one the validator is on) is on or before the date
+ * in the target field, e.g. a start date that can't be after its end date. Either field may hold
+ * an ISO `YYYY-MM-DD` string or epoch milliseconds; no error while either is empty.
+ * @param target - the other date field, e.g. `'END_DATE'`
+ * @param message - the error shown on the current field; defaults to `Must not be after <target>`
+ * @returns a validator function that will be run by the smart form during the client-side validation stage
+ * @public
+ */
+export const mustBeOnOrBefore = (target, message = `Must not be after ${target}`) => dateOrderValidator(target, (value, targetValue) => value > targetValue, message);
 const describeError = (prop, parentProps) => {
     const pSchema = parentProps[prop] || {};
     const constraints = ['required'];