@adaptabletools/adaptable-cjs 22.0.0-canary.2 → 22.0.0-canary.4

package/src/migration/AdaptableUpgradeHelper.js

@@ -6,6 +6,7 @@ const VersionUpgrade18_1 = require("./VersionUpgrade18");
 const EnvVars_1 = require("../EnvVars");
 const VersionUpgrade20_1 = require("./VersionUpgrade20");
 const VersionUpgrade21_1 = require("./VersionUpgrade21");
+const VersionUpgrade22_1 = require("./VersionUpgrade22");
 class AdaptableUpgradeHelper {
     currentMajorVersion;
     versionUpgrades;
@@ -18,6 +19,7 @@ class AdaptableUpgradeHelper {
         this.versionUpgrades.set(18, new VersionUpgrade18_1.VersionUpgrade18(this.logger));
         this.versionUpgrades.set(20, new VersionUpgrade20_1.VersionUpgrade20(this.logger));
         this.versionUpgrades.set(21, new VersionUpgrade21_1.VersionUpgrade21(this.logger));
+        this.versionUpgrades.set(22, new VersionUpgrade22_1.VersionUpgrade22(this.logger));
     }
     static migrateAdaptableState(state, config) {
         const upgradeHelper = new AdaptableUpgradeHelper(config.logger);
@@ -44,7 +46,7 @@ class AdaptableUpgradeHelper {
     }
     getCurrentMajorVersion(version) {
         // is good enough for now, we just need to make sure we don't forget to update it
-        return parseInt(version.split('.')[0]) || 20;
+        return parseInt(version.split('.')[0]) || 22;
     }
     getConsoleLogger() {
         return {

package/src/migration/VersionUpgrade22.d.ts

@@ -0,0 +1,21 @@
+import { VersionUpgrade } from './VersionUpgrade';
+import { AdaptableState } from '../AdaptableState/AdaptableState';
+export declare class VersionUpgrade22 extends VersionUpgrade {
+    migrateState(state: AdaptableState): AdaptableState;
+    private migrateNamedObjectState;
+    private migrateFormatColumnState;
+    private patchCustomSortName;
+    private patchFlashingCellName;
+    private patchFormatColumnName;
+    private patchPlusMinusNudgeName;
+    private patchShortcutName;
+    private patchAlertName;
+    private patchScheduleName;
+    private scopeToString;
+    private hashStrings;
+    /**
+     * Stringifies an object after removing metadata properties (Uuid, Source, AdaptableVersion)
+     * to ensure deterministic hashing regardless of generated values.
+     */
+    private stringifyWithoutMetadata;
+}

package/src/migration/VersionUpgrade22.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersionUpgrade22 = void 0;
+const VersionUpgrade_1 = require("./VersionUpgrade");
+const AdaptableHelper_1 = require("../Utilities/Helpers/AdaptableHelper");
+class VersionUpgrade22 extends VersionUpgrade_1.VersionUpgrade {
+    migrateState(state) {
+        this.migrateFormatColumnState(state);
+        this.migrateNamedObjectState(state);
+        return state;
+    }
+    migrateNamedObjectState(state) {
+        this.patchCustomSortName(state.CustomSort);
+        this.patchFlashingCellName(state.FlashingCell);
+        this.patchFormatColumnName(state.FormatColumn);
+        this.patchPlusMinusNudgeName(state.PlusMinus);
+        this.patchShortcutName(state.Shortcut);
+        this.patchAlertName(state.Alert);
+        this.patchScheduleName(state.Schedule);
+    }
+    // We have moved CellAlignment (renamed Alignment) from independent property into Style
+    migrateFormatColumnState(state) {
+        const formatColumnState = state.FormatColumn;
+        if (formatColumnState && formatColumnState.FormatColumns) {
+            formatColumnState.FormatColumns = formatColumnState.FormatColumns.map((formatColumn) => {
+                //@ts-ignore
+                if (formatColumn.CellAlignment) {
+                    formatColumn.Style = {
+                        ...formatColumn.Style,
+                        //@ts-ignore
+                        Alignment: formatColumn.CellAlignment,
+                    };
+                    //@ts-ignore
+                    delete formatColumn.CellAlignment;
+                }
+                return formatColumn;
+            });
+        }
+        return state;
+    }
+    patchCustomSortName(customSortState) {
+        if (!customSortState) {
+            return;
+        }
+        customSortState.CustomSorts?.forEach((customSort) => {
+            if (!customSort.Name) {
+                const sortedValues = (customSort.SortedValues || []).join();
+                customSort.Name = `CustomSort-${customSort.ColumnId}-${this.hashStrings(['CustomSort', customSort.ColumnId, sortedValues])}`;
+            }
+        });
+    }
+    patchFlashingCellName(flashingCellState) {
+        if (!flashingCellState) {
+            return;
+        }
+        flashingCellState.FlashingCellDefinitions?.forEach((flashingCell) => {
+            if (!flashingCell.Name) {
+                const scopeStr = this.scopeToString(flashingCell.Scope);
+                const ruleStr = flashingCell.Rule?.BooleanExpression || '';
+                flashingCell.Name = `FlashingCell-${this.hashStrings(['FlashingCell', scopeStr, ruleStr])}`;
+            }
+        });
+    }
+    patchFormatColumnName(formatColumnState) {
+        if (!formatColumnState) {
+            return;
+        }
+        formatColumnState.FormatColumns?.forEach((formatColumn) => {
+            if (!formatColumn.Name) {
+                const scopeStr = this.scopeToString(formatColumn.Scope);
+                const styleStr = this.stringifyWithoutMetadata(formatColumn.Style);
+                formatColumn.Name = `FormatColumn-${this.hashStrings(['FormatColumn', scopeStr, styleStr])}`;
+            }
+        });
+    }
+    patchPlusMinusNudgeName(plusMinusState) {
+        if (!plusMinusState) {
+            return;
+        }
+        plusMinusState.PlusMinusNudges?.forEach((nudge) => {
+            if (!nudge.Name) {
+                const scopeStr = this.scopeToString(nudge.Scope);
+                const nudgeValue = String(nudge.NudgeValue ?? '');
+                nudge.Name = `PlusMinus-${this.hashStrings(['PlusMinus', scopeStr, nudgeValue])}`;
+            }
+        });
+    }
+    patchShortcutName(shortcutState) {
+        if (!shortcutState) {
+            return;
+        }
+        shortcutState.Shortcuts?.forEach((shortcut) => {
+            if (!shortcut.Name) {
+                const key = shortcut.ShortcutKey || '';
+                const operation = shortcut.ShortcutOperation || '';
+                const value = String(shortcut.ShortcutValue ?? '');
+                shortcut.Name = `Shortcut-${key}-${this.hashStrings(['Shortcut', key, operation, value])}`;
+            }
+        });
+    }
+    patchAlertName(alertState) {
+        if (!alertState) {
+            return;
+        }
+        alertState.AlertDefinitions?.forEach((alert) => {
+            if (!alert.Name) {
+                const scopeStr = this.scopeToString(alert.Scope);
+                const messageType = alert.MessageType || '';
+                const ruleStr = this.stringifyWithoutMetadata(alert.Rule);
+                alert.Name = `Alert-${messageType}-${this.hashStrings(['Alert', scopeStr, messageType, ruleStr])}`;
+            }
+        });
+    }
+    patchScheduleName(scheduleState) {
+        if (!scheduleState) {
+            return;
+        }
+        // Patch Reminder Schedules
+        scheduleState.Reminders?.forEach((reminder) => {
+            if (!reminder.Name) {
+                const header = reminder.Header || '';
+                const message = reminder.Message || '';
+                reminder.Name = `Reminder-${this.hashStrings(['Reminder', header, message])}`;
+            }
+        });
+        // Patch Report Schedules
+        scheduleState.ReportSchedules?.forEach((report) => {
+            if (!report.Name) {
+                const reportName = report.ReportName || '';
+                const format = report.ReportFormat || '';
+                report.Name = `ReportSchedule-${this.hashStrings(['ReportSchedule', reportName, format])}`;
+            }
+        });
+        // Patch IPushPull Schedules
+        scheduleState.IPushPullSchedules?.forEach((ipp) => {
+            if (!ipp.Name) {
+                const reportName = ipp.IPushPullReport?.ReportName || '';
+                const folder = ipp.IPushPullReport?.Folder || '';
+                const page = ipp.IPushPullReport?.Page || '';
+                ipp.Name = `IPushPullSchedule-${this.hashStrings(['IPushPullSchedule', reportName, folder, page])}`;
+            }
+        });
+        // Patch OpenFin Schedules
+        scheduleState.OpenFinSchedules?.forEach((openfin) => {
+            if (!openfin.Name) {
+                const reportName = openfin.OpenFinReport?.ReportName || '';
+                openfin.Name = `OpenFinSchedule-${this.hashStrings(['OpenFinSchedule', reportName])}`;
+            }
+        });
+    }
+    scopeToString(scope) {
+        if (!scope) {
+            return '';
+        }
+        if ('All' in scope && scope.All) {
+            return 'All';
+        }
+        if ('ColumnIds' in scope && scope.ColumnIds) {
+            return scope.ColumnIds.join(',');
+        }
+        if ('DataTypes' in scope && scope.DataTypes) {
+            return scope.DataTypes.join(',');
+        }
+        if ('ColumnTypes' in scope && scope.ColumnTypes) {
+            return scope.ColumnTypes.join(',');
+        }
+        return '';
+    }
+    hashStrings(strings) {
+        let hash = 0;
+        for (const str of strings) {
+            for (let i = 0; i < str.length; i++) {
+                hash = (hash * 31 + str.charCodeAt(i)) % 9000;
+            }
+        }
+        return hash + 1000;
+    }
+    /**
+     * Stringifies an object after removing metadata properties (Uuid, Source, AdaptableVersion)
+     * to ensure deterministic hashing regardless of generated values.
+     */
+    stringifyWithoutMetadata(obj) {
+        if (!obj) {
+            return '';
+        }
+        const cloned = structuredClone(obj);
+        (0, AdaptableHelper_1.removeAdaptableObjectPrimitivesInlineDeep)(cloned);
+        return JSON.stringify(cloned);
+    }
+}
+exports.VersionUpgrade22 = VersionUpgrade22;

package/src/types.d.ts

@@ -157,8 +157,7 @@ export type { SystemStatusMessageInfo } from './AdaptableState/Common/SystemStat
 export type { AlternativeModuleName } from './AdaptableState/Common/AlternativeModuleName';
 export type { AdaptableFormat, DateFormatterOptions, NumberFormatterOptions, StringFormatterOptions, } from './AdaptableState/Common/AdaptableFormat';
 export type { AdaptableMessageType } from './AdaptableState/Common/AdaptableMessageType';
-export type { AdaptableObject, AdaptableObjectTag, AdaptableObjectLookupCriteria, AdaptableVersion, } from './AdaptableState/Common/AdaptableObject';
-export type { SuspendableObject } from './AdaptableState/Common/SuspendableObject';
+export type { Identifiable, AdaptableObject, AdaptableObjectTag, AdaptableObjectLookupCriteria, AdaptableVersion, SuspendableObject, NamedObject, } from './AdaptableState/Common/AdaptableObject';
 export type { AdaptableQuery, AdaptableAggregatedBooleanQuery, AdaptableAggregatedScalarQuery, AdaptableBooleanQuery, AdaptableObservableQuery, AdaptableScalarQuery, } from './AdaptableState/Common/AdaptableQuery';
 export type { AdaptablePredicate, AdaptableColumnPredicate, AdaptablePredicateDef, PredicateModuleScope, PredicateDefHandlerContext, PredicateDefInput, PredicateDefToStringParams, ColumnFilterDef, } from './AdaptableState/Common/AdaptablePredicate';
 export type { ColumnScope } from './AdaptableState/Common/ColumnScope';
@@ -188,7 +187,7 @@ export type { DashboardState, DashboardTab, AdaptableCoordinate, } from './Adapt
 export type { ExportState, Report, ReportData, ReportColumn, ReportSchedule, SystemReportName, SystemReportNames, SystemReportFormat, ReportRowScope, ReportColumnScope, ReportNameType, ReportFormatType, } from './AdaptableState/ExportState';
 export type { ColumnFilter, ColumnFilterPredicate, SystemFilterPredicateIds, SystemFilterPredicateId, PredicatesOperator, } from './AdaptableState/Common/ColumnFilter';
 export type { GridFilter } from './AdaptableState/Common/GridFilter';
-export type { FormatColumn, FormatColumnState, FormatColumnRule, FormatColumnPredicate, SystemFormatColumnPredicateId, SystemFormatColumnPredicateIds, CellAlignment, ColumnGroupScope, FormatColumnTarget, FormatColumnConfig, } from './AdaptableState/FormatColumnState';
+export type { FormatColumn, FormatColumnState, FormatColumnRule, FormatColumnPredicate, SystemFormatColumnPredicateId, SystemFormatColumnPredicateIds, ColumnGroupScope, FormatColumnTarget, FormatColumnConfig, } from './AdaptableState/FormatColumnState';
 export type { StyledColumn, StyledColumnState, PercentBarStyle, GradientStyle, CellColorRange, ColumnComparison, CellTextOptions, CellTextOption, NumericStyledColumn, RangeValueType, SparklineStyle, BadgeStyle, BadgeStyleDefinition, BadgeStylePredicate, SystemBadgeStylePredicateId, SystemBadgeStylePredicateIds, } from './AdaptableState/StyledColumnState';
 export type { FreeTextColumn, FreeTextColumnState, FreeTextStoredValue, FreeTextColumnSettings, } from './AdaptableState/FreeTextColumnState';
 export type { StatusBarState, AdaptableStatusBar } from './AdaptableState/StatusBarState';