@genesislcap/foundation-ui 14.246.2 → 14.247.1

package/dist/esm/scheduler-cron-builder/scheduler-cron-builder.js

@@ -0,0 +1,289 @@
+import { __decorate } from "tslib";
+import { showNotificationToast } from '@genesislcap/foundation-notifications';
+import { attr, observable, volatile } from '@microsoft/fast-element';
+import { FoundationElement } from '@microsoft/fast-foundation';
+import { getPrefix } from '../utils';
+import { buildConfigForDailyRecurrence, buildConfigForMonthlyRecurrence, buildConfigForWeeklyRecurrence, buildConfigForYearlyRecurrence, formatFrequency, getCronExpressionForDaily, getCronExpressionForMonth, getCronExpressionForWeekly, getCronExpressionForYear, isValidCron, parseCronExpression, } from './helpers';
+import { schedulerCronBuilderStyles as styles } from './scheduler-cron-builder.styles';
+import { foundationSchedulerCronBuilderTemplate as template } from './scheduler-cron-builder.template';
+import { CronBuilderEvents, DateOrDay, MAX_DAYS, MAX_MONTHS, RecurrenceType, WeekType, } from './types';
+/**
+ * @tagname %%prefix%%-scheduler-cron-builder
+ */
+export class SchedulerCronBuilder extends FoundationElement {
+    constructor() {
+        super(...arguments);
+        this.getConfigs = {
+            buildConfigForDailyRecurrence,
+            buildConfigForWeeklyRecurrence,
+            buildConfigForMonthlyRecurrence,
+            buildConfigForYearlyRecurrence,
+        };
+        /**
+         * Used to store the recurrence type of an event.
+         * This variable determines how often an event repeats including Daily, Weekly, Monthly, Yearly.
+         * See {@link RecurrenceType}
+         * @internal
+         */
+        this.recurrence = RecurrenceType.DAILY;
+        /**
+         * used to store the cron string generated as result of selected input
+         * @example
+         * `"0 30 10 ? * 2-6"` runs on weekdays from monday-friday at 10:30
+         *
+         */
+        this.cron = '';
+        /**
+         * Used to store the cron expression
+         * added to make sync directive work as it checks value field in the change event
+         * @internal
+         */
+        this.value = this.cron;
+        /**
+         * Used to store the config for each recurrence type in form of an object.
+         * See {@link CronConfig}
+         * @internal
+         */
+        this.cronConfig = {
+            type: RecurrenceType.DAILY,
+            weekType: WeekType.WEEK,
+            hours: '0',
+            minutes: '0',
+            seconds: '0',
+        };
+        /**
+         * Used to store the frequency of an event's recurrence
+         *
+         * Represents the interval between recurrences, based on the {@link RecurrenceType}
+         *
+         * e.g. a value of '3' means that the event occurs every third occurrence (every 3 months for 'MONTHLY' recurrence)
+         * MUST contain a positive value from {@link frequencyList}
+         * @internal
+         */
+        this.frequency = '1';
+        /**
+         * The hour  at which the event should occurs
+         * @internal
+         */
+        this.hours = '0';
+        /**
+         * The minute  at which the event should occurs
+         * @internal
+         */
+        this.minutes = '0';
+        /**
+         * The second  at which the event should occurs
+         * @internal
+         */
+        this.seconds = '0';
+        this.timezone = '';
+    }
+    cronChanged() {
+        if (!this.cron)
+            return;
+        try {
+            if (!isValidCron(this.cron)) {
+                showNotificationToast({
+                    title: 'Cron Scheduler',
+                    body: `Invalid Cron Expression`,
+                    toast: { type: 'critical' },
+                }, getPrefix(this));
+                return;
+            }
+            this.setsFieldsFromCronEx();
+        }
+        catch (error) {
+            console.error('Error:', error);
+            showNotificationToast({
+                title: 'Cron Scheduler',
+                body: error,
+                toast: { type: 'critical' },
+            }, getPrefix(this));
+            return;
+        }
+    }
+    /**
+     * The suffix that appears with frequency field
+     *
+     * @remarks This property updates every time recurrence is changed.
+     * Use it to determine the suffix specific to selected recurrence (e.g. `Days` for `DAILY` recurrenceType).
+     */
+    get frequencySuffix() {
+        switch (this.cronConfig.type) {
+            case RecurrenceType.DAILY:
+                return 'Day(s)';
+            case RecurrenceType.MONTHLY:
+                return 'Month(s)';
+            default:
+                return '';
+        }
+    }
+    /**
+     * The frequency dropdown list
+     *
+     * @remarks This property updates every time recurrence type is changed.
+     * Used to update the list size on basis of recurrence type e.g. 12 for month recurrence
+     */
+    get frequencyList() {
+        switch (this.cronConfig.type) {
+            case RecurrenceType.DAILY:
+                return Array.from({ length: MAX_DAYS }, (_, i) => i + 1);
+            case RecurrenceType.MONTHLY:
+                return Array.from({ length: MAX_MONTHS }, (_, i) => i + 1);
+            case RecurrenceType.YEARLY:
+                return Array.from({ length: MAX_MONTHS }, (_, i) => i + 1);
+            default:
+                return [];
+        }
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        this.addEventListener(CronBuilderEvents.updateCronConfig, this.handleCronConfigUpdate);
+    }
+    disconnectedCallback() {
+        this.removeEventListener(CronBuilderEvents.updateCronConfig, this.handleCronConfigUpdate);
+    }
+    getBaseConfigFields() {
+        return {
+            frequency: this.frequency,
+            hours: this.hours,
+            minutes: this.minutes,
+            seconds: this.seconds,
+        };
+    }
+    /**
+     * sets default value for recurrence in cronConfig and generates cron expression
+     * @internal
+     */
+    handleRecurrenceChange() {
+        switch (this.recurrence) {
+            case RecurrenceType.DAILY:
+                this.cronConfig = Object.assign(Object.assign({ type: RecurrenceType.DAILY }, this.getBaseConfigFields()), { weekType: WeekType.WEEK });
+                this.generateCronExpressionFromConfig(this.cronConfig);
+                break;
+            case RecurrenceType.WEEKLY:
+                this.cronConfig = Object.assign(Object.assign({ type: RecurrenceType.WEEKLY }, this.getBaseConfigFields()), { selectedDays: new Set() });
+                this.generateCronExpressionFromConfig(this.cronConfig);
+                break;
+            case RecurrenceType.MONTHLY:
+                this.cronConfig = Object.assign(Object.assign({ type: RecurrenceType.MONTHLY }, this.getBaseConfigFields()), { dateOrDay: {
+                        type: DateOrDay.DATE,
+                        dayDate: '1',
+                    } });
+                this.generateCronExpressionFromConfig(this.cronConfig);
+                break;
+            case RecurrenceType.YEARLY:
+                this.cronConfig = Object.assign(Object.assign({ type: RecurrenceType.YEARLY }, this.getBaseConfigFields()), { dateOrDay: {
+                        type: DateOrDay.DATE,
+                        dayDate: '1',
+                        month: '1',
+                    } });
+                this.generateCronExpressionFromConfig(this.cronConfig);
+                break;
+            default:
+                showNotificationToast({
+                    title: 'Cron Scheduler',
+                    body: `Recurrence type should be one of the known types: Daily, Weekly,Monthly or Yearly`,
+                    toast: { type: 'critical' },
+                }, getPrefix(this));
+        }
+    }
+    /**
+     * change event for each input field including frequency, hours, minutes and seconds
+     * @internal
+     */
+    handleChange(fieldName) {
+        this.cronConfig[fieldName] = this[fieldName];
+        this.generateCronExpressionFromConfig(this.cronConfig);
+    }
+    /**
+     * event listener used to update cron config and cron expression
+     * @internal
+     */
+    handleCronConfigUpdate({ detail }) {
+        this.cronConfig = Object.assign(Object.assign({}, this.getBaseConfigFields()), detail);
+        this.generateCronExpressionFromConfig(this.cronConfig);
+    }
+    /**
+     * method that updates cron string on basis of config for each recurrence type
+     * @internal
+     */
+    generateCronExpressionFromConfig(config) {
+        switch (config.type) {
+            case RecurrenceType.DAILY:
+                this.cron = getCronExpressionForDaily(config, formatFrequency);
+                break;
+            case RecurrenceType.WEEKLY:
+                this.cron = getCronExpressionForWeekly(config);
+                break;
+            case RecurrenceType.MONTHLY:
+                this.cron = getCronExpressionForMonth(config, formatFrequency);
+                break;
+            case RecurrenceType.YEARLY:
+                this.cron = getCronExpressionForYear(config);
+                break;
+            default:
+                showNotificationToast({
+                    title: 'Cron Scheduler',
+                    body: `Recurrence type should be one of the known types: Daily, Weekly,Monthly or Yearly`,
+                    toast: { type: 'critical' },
+                }, getPrefix(this));
+        }
+        this.value = this.cron;
+        this.$emit('change');
+    }
+    /**
+     * parses a cron expression and sets fields from it
+     * @internal
+     */
+    setsFieldsFromCronEx() {
+        this.cronConfig = parseCronExpression(this.cron, this.getConfigs);
+        this.recurrence = this.cronConfig.type;
+        this.frequency = this.cronConfig.frequency;
+        this.hours = this.cronConfig.hours;
+        this.minutes = this.cronConfig.minutes;
+        this.seconds = this.cronConfig.seconds;
+    }
+}
+__decorate([
+    observable
+], SchedulerCronBuilder.prototype, "recurrence", void 0);
+__decorate([
+    observable
+], SchedulerCronBuilder.prototype, "cron", void 0);
+__decorate([
+    observable
+], SchedulerCronBuilder.prototype, "cronConfig", void 0);
+__decorate([
+    observable
+], SchedulerCronBuilder.prototype, "frequency", void 0);
+__decorate([
+    observable
+], SchedulerCronBuilder.prototype, "hours", void 0);
+__decorate([
+    observable
+], SchedulerCronBuilder.prototype, "minutes", void 0);
+__decorate([
+    observable
+], SchedulerCronBuilder.prototype, "seconds", void 0);
+__decorate([
+    volatile
+], SchedulerCronBuilder.prototype, "frequencySuffix", null);
+__decorate([
+    volatile
+], SchedulerCronBuilder.prototype, "frequencyList", null);
+__decorate([
+    attr
+], SchedulerCronBuilder.prototype, "timezone", void 0);
+// explicitly declaring for extensibility
+export const foundationSchedulerCronBuilderShadowOptions = undefined;
+export const defaultCronBuilderConfig = {};
+/**
+ * The Foundation Cron Scheduler Builder
+ *
+ * @public
+ * @remarks
+ * HTML Element: \<foundation-scheduler-cron-builder\>
+ */
+export const foundationSchedulerCronBuilder = SchedulerCronBuilder.compose(Object.assign({ baseName: 'scheduler-cron-builder', styles,
+    template, shadowOptions: foundationSchedulerCronBuilderShadowOptions }, defaultCronBuilderConfig));

package/dist/esm/scheduler-cron-builder/scheduler-cron-builder.styles.js

@@ -0,0 +1,72 @@
+import { css } from '@microsoft/fast-element';
+export const inputControls = css `
+  .input-container {
+    display: flex;
+    flex-direction: column;
+    gap: calc(var(--design-unit) * 2px);
+  }
+
+  .label {
+    color: var(--neutral-foreground-hint);
+    display: block;
+    cursor: pointer;
+    font-size: var(--type-ramp-base-font-size);
+    line-height: var(--type-ramp-base-line-height);
+    font-style: normal;
+  }
+
+  .row {
+    display: flex;
+    width: 50%;
+    align-items: center;
+    gap: calc(var(--design-unit) * 4px);
+  }
+`;
+export const schedulerCronBuilderStyles = css `
+  ${inputControls}
+  /* Host */
+  :host {
+    display: flex;
+    flex-direction: column;
+    width: 100%;
+  }
+
+  .container {
+    padding: calc(var(--design-unit) * 2px) calc(var(--design-unit) * 4px);
+    display: flex;
+    flex-direction: column;
+    gap: calc(var(--design-unit) * 4px);
+  }
+
+  .flex-row {
+    display: flex;
+    align-items: center;
+    gap: calc(var(--design-unit) * 4px);
+  }
+
+  .time-select {
+    min-width: 110px;
+    position: relative;
+  }
+
+  .frequency-select {
+    position: relative;
+  }
+
+  .frequency-select::part(end),
+  .time-select::part(end) {
+    min-width: 0;
+    width: 0;
+  }
+
+  .suffix-label {
+    position: absolute;
+    right: 35px; /* Move it before the icon */
+    top: 50%;
+    transform: translateY(-50%);
+    padding: 0 calc(var(--design-unit) * 1px);
+    color: var(--neutral-foreground-hint);
+    font-size: var(--type-ramp-minus-1-font-size);
+    white-space: nowrap;
+  }
+`;

package/dist/esm/scheduler-cron-builder/scheduler-cron-builder.template.js

@@ -0,0 +1,101 @@
+import { sync } from '@genesislcap/foundation-utils';
+import { html, repeat, when } from '@microsoft/fast-element';
+import { getPrefix } from '../utils';
+import { DailyRecurrence } from './daily-recurrence/daily-recurrence';
+import { MonthlyYearlyRecurrence } from './monthly-yearly-recurrence/monthly-yearly-recurrence';
+import { MAX_HOURS, MAX_MINS_SEC, RecurrenceType } from './types';
+import { WeeklyRecurrence } from './weekly-recurrence/weekly-recurrence';
+DailyRecurrence;
+WeeklyRecurrence;
+MonthlyYearlyRecurrence;
+const dailyTemplate = (prefix) => html `
+  <daily-recurrence :prefix=${() => prefix} :config=${(x) => x.cronConfig}></daily-recurrence>
+`;
+const weeklyTemplate = (prefix) => html `
+  <weekly-recurrence :prefix=${() => prefix} :config=${(x) => x.cronConfig}></weekly-recurrence>
+`;
+const monthlyOrYearlyTemplate = (prefix) => html `
+  <monthly-yearly-recurrence
+    :prefix=${() => prefix}
+    :config=${(x) => x.cronConfig}
+  ></monthly-yearly-recurrence>
+`;
+export const getPrefixedCronBuilder = (prefix) => html `
+  <template>
+    <div class="container">
+      <div class="input-container">
+        <label class="label">Recurrence</label>
+        <${prefix}-select
+          data-test-id="select-recurrence"
+          :value=${sync((x) => x.recurrence)}
+          @change="${(x) => x.handleRecurrenceChange()}"
+        >
+          <${prefix}-option data-test-id="${RecurrenceType.DAILY}">
+            ${RecurrenceType.DAILY}
+          </${prefix}-option>
+          <${prefix}-option data-test-id="${RecurrenceType.WEEKLY}">
+            ${RecurrenceType.WEEKLY}
+          </${prefix}-option>
+          <${prefix}-option data-test-id="${RecurrenceType.MONTHLY}">
+            ${RecurrenceType.MONTHLY}
+          </${prefix}-option>
+          <${prefix}-option data-test-id="${RecurrenceType.YEARLY}">
+            ${RecurrenceType.YEARLY}
+          </${prefix}-option>
+        </${prefix}-select>
+      </div>   
+      <div class="row">
+      ${when((x) => x.recurrence === RecurrenceType.DAILY || x.recurrence === RecurrenceType.MONTHLY, html `
+        <div class="input-container">
+          <label class="label"> Frequency in ${(x) => x.frequencySuffix}</label>
+          <${prefix}-select class="frequency-select"  data-test-id="frequency-dropdown"  :value=${sync((x) => x.frequency)} @change="${(x) => x.handleChange('frequency')}" >
+            ${repeat((x) => x.frequencyList, html `
+                <${prefix}-option value="${(x) => x}">
+                  ${(x) => x}
+                </${prefix}-option>
+              `)}
+              <div slot="end" class="suffix-label">${(x) => x.frequencySuffix}</div>
+          </${prefix}-select>
+        </div>`)}
+        <div class="input-container">
+          <label class="label">Time </label>
+          <div class="flex-row">
+            <${prefix}-select  class="time-select" data-test-id="hours-dropdown" :value=${sync((x) => x.hours)} @change="${(x) => x.handleChange('hours')}" >
+              ${repeat(() => Array.from({ length: MAX_HOURS }, (_, i) => i), html `
+                  <${prefix}-option value="${(x) => x}">
+                    ${(x) => x}
+                  </${prefix}-option>
+                `)}
+               <div slot="end" class="suffix-label">hr</div>
+            </${prefix}-select>
+            <${prefix}-select  class="time-select" data-test-id="mins-dropdown" :value=${sync((x) => x.minutes)} @change="${(x) => x.handleChange('minutes')}" >
+              ${repeat(() => Array.from({ length: MAX_MINS_SEC }, (_, i) => i), html `
+                  <${prefix}-option value="${(x) => x}">
+                    ${(x) => x}
+                  </${prefix}-option>
+                `)}
+               <div slot="end" class="suffix-label">min</div>
+            </${prefix}-select>
+            <${prefix}-select class="time-select" data-test-id="seconds-dropdown" :value=${sync((x) => x.seconds)} @change="${(x) => x.handleChange('seconds')}" >
+              ${repeat(() => Array.from({ length: MAX_MINS_SEC }, (_, i) => i), html `
+                  <${prefix}-option value="${(x) => x}">
+                    ${(x) => x}
+                  </${prefix}-option>
+                `)}
+               <div slot="end" class="suffix-label">sec</div>
+            </${prefix}-select>
+          </div>
+        </div>
+      </div>
+
+      ${when((x) => x.recurrence === RecurrenceType.DAILY, dailyTemplate(prefix))}
+      ${when((x) => x.recurrence === RecurrenceType.WEEKLY, weeklyTemplate(prefix))}
+      ${when((x) => x.recurrence === RecurrenceType.MONTHLY || x.recurrence === RecurrenceType.YEARLY, monthlyOrYearlyTemplate(prefix))}
+
+    </div>
+
+  </template>
+`;
+export const foundationSchedulerCronBuilderTemplate = html `
+  ${(x) => getPrefixedCronBuilder(getPrefix(x))}
+`;

package/dist/esm/scheduler-cron-builder/types.js

@@ -0,0 +1,67 @@
+/**
+ * Defines allowed recurrence types including Daily, Weekly, Monthly, Yearly.
+ * @internal
+ */
+export var RecurrenceType;
+(function (RecurrenceType) {
+    RecurrenceType["DAILY"] = "Daily";
+    RecurrenceType["WEEKLY"] = "Weekly";
+    RecurrenceType["MONTHLY"] = "Monthly";
+    RecurrenceType["YEARLY"] = "Yearly";
+})(RecurrenceType || (RecurrenceType = {}));
+/** @internal */
+export var WeekType;
+(function (WeekType) {
+    WeekType["WEEK"] = "Week";
+    WeekType["WORK_WEEK"] = "Work week";
+})(WeekType || (WeekType = {}));
+/** @internal */
+export var DateOrDay;
+(function (DateOrDay) {
+    DateOrDay["DATE"] = "Date";
+    DateOrDay["DAY_OF_MONTH"] = "Day of month";
+})(DateOrDay || (DateOrDay = {}));
+/** @internal */
+export const daysOfWeek = [
+    { value: '2', label: 'Monday' },
+    { value: '3', label: 'Tuesday' },
+    { value: '4', label: 'Wednesday' },
+    { value: '5', label: 'Thursday' },
+    { value: '6', label: 'Friday' },
+    { value: '7', label: 'Saturday' },
+    { value: '1', label: 'Sunday' },
+];
+/** @internal */
+export const weekNumber = [
+    { value: '1', label: 'First' },
+    { value: '2', label: 'Second' },
+    { value: '3', label: 'Third' },
+    { value: '4', label: 'Fourth' },
+    { value: '-1', label: 'Last' },
+];
+/** @internal */
+export const months = [
+    { value: '1', label: 'January' },
+    { value: '2', label: 'February' },
+    { value: '3', label: 'March' },
+    { value: '4', label: 'April' },
+    { value: '5', label: 'May' },
+    { value: '6', label: 'June' },
+    { value: '7', label: 'July' },
+    { value: '8', label: 'August' },
+    { value: '9', label: 'September' },
+    { value: '10', label: 'October' },
+    { value: '11', label: 'November' },
+    { value: '12', label: 'December' },
+];
+export const MAX_MONTHS = 12;
+export const MAX_DAYS = 31;
+export const CRON_LENGTH = 6;
+export const MAX_WEEK_DAYS = 7;
+export const MAX_HOURS = 24;
+export const MAX_MINS_SEC = 60;
+export const MAX_WEEK_NUMBER = 4;
+export var CronBuilderEvents;
+(function (CronBuilderEvents) {
+    CronBuilderEvents["updateCronConfig"] = "update-cron-config";
+})(CronBuilderEvents || (CronBuilderEvents = {}));

package/dist/esm/scheduler-cron-builder/weekly-recurrence/weekly-recurrence.js

@@ -0,0 +1,59 @@
+import { __decorate } from "tslib";
+import { EventEmitter } from '@genesislcap/foundation-events';
+import { customElement, observable } from '@microsoft/fast-element';
+import { FoundationElement } from '@microsoft/fast-foundation';
+import { CronBuilderEvents } from '../types';
+import { weeklyRecurrenceStyles as styles } from './weekly-recurrence.styles';
+import { weeklyRecurrenceTemplate as template } from './weekly-recurrence.template';
+let WeeklyRecurrence = class WeeklyRecurrence extends EventEmitter(FoundationElement) {
+    constructor() {
+        super(...arguments);
+        /**
+         * Used for storing specific Week days (Monday-Sunday) on which the event should occurs
+         */
+        this.selectedDays = new Set();
+    }
+    configChanged() {
+        var _a;
+        this.selectedDays = ((_a = this.config) === null || _a === void 0 ? void 0 : _a.selectedDays)
+            ? new Set([...this.config.selectedDays])
+            : new Set();
+    }
+    /**
+     * used to add or remove days of week in set on basis of user selection,
+     * and update cron expression as well
+     * @internal
+     * */
+    checkboxChangeHandler(event) {
+        const { checked, value } = event.target;
+        if (checked) {
+            this.selectedDays.add(value);
+        }
+        else {
+            this.selectedDays.delete(value);
+        }
+        this.updateCronConfig();
+    }
+    /**
+     * emits an event to update cron config and cron expression for weekly config
+     * @internal
+     * */
+    updateCronConfig() {
+        this.config = Object.assign(Object.assign({}, this.config), { selectedDays: this.selectedDays });
+        this.$emit(CronBuilderEvents.updateCronConfig, this.config);
+    }
+};
+__decorate([
+    observable
+], WeeklyRecurrence.prototype, "prefix", void 0);
+__decorate([
+    observable
+], WeeklyRecurrence.prototype, "config", void 0);
+WeeklyRecurrence = __decorate([
+    customElement({
+        name: 'weekly-recurrence',
+        template,
+        styles,
+    })
+], WeeklyRecurrence);
+export { WeeklyRecurrence };

package/dist/esm/scheduler-cron-builder/weekly-recurrence/weekly-recurrence.styles.js

@@ -0,0 +1,9 @@
+import { css } from '@microsoft/fast-element';
+import { inputControls } from '../scheduler-cron-builder.styles';
+export const weeklyRecurrenceStyles = css `
+  ${inputControls}
+  .weekdays-row {
+    display: flex;
+    gap: calc(var(--design-unit) * 3px);
+  }
+`;

package/dist/esm/scheduler-cron-builder/weekly-recurrence/weekly-recurrence.template.js

@@ -0,0 +1,25 @@
+import { html, repeat } from '@microsoft/fast-element';
+import { daysOfWeek } from '../types';
+export const getPrefixedWeeklyRecurrence = (prefix) => html `
+  <template>
+    <div class="input-container">
+      <label class="label">On</label>
+      <div class="weekdays-row">
+        ${repeat(() => daysOfWeek, html `
+          <${prefix}-checkbox 
+            part="weekdays-checkbox"
+            class="weekdays-checkbox"
+            :value=${(x) => x.value}
+            ?checked=${(x, c) => c.parent.selectedDays.has(x.value)}
+            @change=${(x, c) => c.parent.checkboxChangeHandler(c.event)}
+          > 
+            ${(x) => x.label}
+          </${prefix}-checkbox>
+        `)}
+      </div>
+    </div>
+  </template>
+`;
+export const weeklyRecurrenceTemplate = html `
+  ${(x) => getPrefixedWeeklyRecurrence(x.prefix)}
+`;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@genesislcap/foundation-ui",
   "description": "Genesis Foundation UI",
-  "version": "14.246.2",
+  "version": "14.247.1",
   "sideEffects": false,
   "license": "SEE LICENSE IN license.txt",
   "main": "dist/esm/index.js",
@@ -83,13 +83,13 @@
     }
   },
   "devDependencies": {
-    "@genesislcap/foundation-testing": "14.246.2",
-    "@genesislcap/genx": "14.246.2",
-    "@genesislcap/rollup-builder": "14.246.2",
-    "@genesislcap/ts-builder": "14.246.2",
-    "@genesislcap/uvu-playwright-builder": "14.246.2",
-    "@genesislcap/vite-builder": "14.246.2",
-    "@genesislcap/webpack-builder": "14.246.2",
+    "@genesislcap/foundation-testing": "14.247.1",
+    "@genesislcap/genx": "14.247.1",
+    "@genesislcap/rollup-builder": "14.247.1",
+    "@genesislcap/ts-builder": "14.247.1",
+    "@genesislcap/uvu-playwright-builder": "14.247.1",
+    "@genesislcap/vite-builder": "14.247.1",
+    "@genesislcap/webpack-builder": "14.247.1",
     "copyfiles": "^2.4.1",
     "rimraf": "^5.0.0",
     "rxjs": "^7.5.4"
@@ -100,13 +100,14 @@
     "@fortawesome/free-regular-svg-icons": "^6.2.1",
     "@fortawesome/free-solid-svg-icons": "^6.2.1",
     "@genesiscommunitysuccess/analyzer-import-alias-plugin": "^5.0.3",
-    "@genesislcap/foundation-comms": "14.246.2",
-    "@genesislcap/foundation-criteria": "14.246.2",
-    "@genesislcap/foundation-errors": "14.246.2",
-    "@genesislcap/foundation-logger": "14.246.2",
-    "@genesislcap/foundation-notifications": "14.246.2",
-    "@genesislcap/foundation-user": "14.246.2",
-    "@genesislcap/foundation-utils": "14.246.2",
+    "@genesislcap/foundation-comms": "14.247.1",
+    "@genesislcap/foundation-criteria": "14.247.1",
+    "@genesislcap/foundation-errors": "14.247.1",
+    "@genesislcap/foundation-events": "14.247.1",
+    "@genesislcap/foundation-logger": "14.247.1",
+    "@genesislcap/foundation-notifications": "14.247.1",
+    "@genesislcap/foundation-user": "14.247.1",
+    "@genesislcap/foundation-utils": "14.247.1",
     "@microsoft/fast-colors": "5.3.1",
     "@microsoft/fast-components": "2.30.6",
     "@microsoft/fast-element": "1.14.0",
@@ -128,5 +129,5 @@
     "access": "public"
   },
   "customElements": "dist/custom-elements.json",
-  "gitHead": "c6f8e26357a167f660fbb7f8ac4873ca358335fd"
+  "gitHead": "e5f84bbc09e62919c3c5cc40a6c28353443827de"
 }