@vuu-ui/vuu-utils 2.1.19-beta.2 → 2.1.19-beta.3

package/cjs/packages/vuu-utils/src/index.js

@@ -0,0 +1,481 @@
+'use strict';
+
+var modifiers = require('../../../node_modules/@dnd-kit/abstract/modifiers.js');
+var index$1 = require('../../../node_modules/@dnd-kit/dom/index.js');
+var index = require('../../../node_modules/@dnd-kit/react/index.js');
+var sortable = require('../../../node_modules/@dnd-kit/react/sortable.js');
+var arrayUtils = require('./array-utils.js');
+var boxUtils = require('./box-utils.js');
+var Clock = require('./Clock.js');
+var columnUtils = require('./column-utils.js');
+var commonTypes = require('./common-types.js');
+var componentRegistry = require('./component-registry.js');
+var cookieUtils = require('./cookie-utils.js');
+var cssUtils = require('./css-utils.js');
+var DataEditingProvider = require('./data-editing/DataEditingProvider.js');
+var editUtils = require('./data-editing/edit-utils.js');
+var EditButtons = require('./data-editing/EditButtons.js');
+var EditSession = require('./data-editing/EditSession.js');
+var useEditableTable = require('./data-editing/useEditableTable.js');
+var dataUtils = require('./data-utils.js');
+var BaseDataSource = require('./datasource/BaseDataSource.js');
+var datasourceActionUtils = require('./datasource/datasource-action-utils.js');
+var datasourceFilterUtils = require('./datasource/datasource-filter-utils.js');
+var datasourceUtils = require('./datasource/datasource-utils.js');
+var dateUtils = require('./date/date-utils.js');
+var dateTimePattern = require('./date/dateTimePattern.js');
+var formatter = require('./date/formatter.js');
+var types = require('./date/types.js');
+var debugUtils = require('./debug-utils.js');
+var eventEmitter = require('./event-emitter.js');
+var featureUtils = require('./feature-utils.js');
+var filterUtils = require('./filters/filter-utils.js');
+var filterAsQuery = require('./filters/filterAsQuery.js');
+var formUtils = require('./form-utils.js');
+var formattingUtils = require('./formatting-utils.js');
+var getUniqueId = require('./getUniqueId.js');
+var groupUtils = require('./group-utils.js');
+var htmlUtils = require('./html-utils.js');
+var inputUtils = require('./input-utils.js');
+var invariant = require('./invariant.js');
+var itemToString = require('./itemToString.js');
+var jsonUtils = require('./json-utils.js');
+var keyboardUtils = require('./keyboard-utils.js');
+var keyset = require('./keyset.js');
+var listUtils = require('./list-utils.js');
+var localStorageUtils = require('./local-storage-utils.js');
+var loggingUtils = require('./logging-utils.js');
+var moduleUtils = require('./module-utils.js');
+var index$2 = require('./nanoid/index.js');
+var perfUtils = require('./perf-utils.js');
+var promiseUtils = require('./promise-utils.js');
+var protocolMessageUtils = require('./protocol-message-utils.js');
+var rangeUtils = require('./range-utils.js');
+var reactUtils = require('./react-utils.js');
+var roundDecimal = require('./round-decimal.js');
+var rowUtils = require('./row-utils.js');
+var ScaledDecimal = require('./ScaledDecimal.js');
+var selectionUtils = require('./selection-utils.js');
+var shellLayoutTypes = require('./shell-layout-types.js');
+var sortUtils = require('./sort-utils.js');
+var tableSchemaUtils = require('./table-schema-utils.js');
+var textUtils = require('./text-utils.js');
+var ThemeProvider = require('./ThemeProvider.js');
+var treeUtils = require('./tree-utils.js');
+var tsUtils = require('./ts-utils.js');
+var typeaheadUtils = require('./typeahead-utils.js');
+var urlUtils = require('./url-utils.js');
+var useId = require('./useId.js');
+var useLayoutEffectSkipFirst = require('./useLayoutEffectSkipFirst.js');
+var useResizeObserver = require('./useResizeObserver.js');
+var useStateRef = require('./useStateRef.js');
+var DataContext = require('./context-definitions/DataContext.js');
+var DataProvider = require('./context-definitions/DataProvider.js');
+var DataSourceProvider = require('./context-definitions/DataSourceProvider.js');
+var WorkspaceContext = require('./context-definitions/WorkspaceContext.js');
+var PageVisibilityObserver = require('./PageVisibilityObserver.js');
+var ShellContext = require('./ShellContext.js');
+var themeUtils = require('./theme-utils.js');
+
+
+
+exports.RestrictToHorizontalAxis = modifiers.RestrictToHorizontalAxis;
+exports.KeyboardSensor = index$1.KeyboardSensor;
+exports.PointerSensor = index$1.PointerSensor;
+exports.DragDropProvider = index.DragDropProvider;
+exports.DragOverlay = index.DragOverlay;
+exports.useInstance = index.useInstance;
+exports.useSortable = sortable.useSortable;
+exports.getAddedItems = arrayUtils.getAddedItems;
+exports.getMissingItems = arrayUtils.getMissingItems;
+exports.itemsChanged = arrayUtils.itemsChanged;
+exports.itemsOrOrderChanged = arrayUtils.itemsOrOrderChanged;
+exports.moveItem = arrayUtils.moveItem;
+exports.moveItemDeprecated = arrayUtils.moveItemDeprecated;
+exports.partition = arrayUtils.partition;
+exports.boxContainsPoint = boxUtils.boxContainsPoint;
+exports.getCenteredBox = boxUtils.getCenteredBox;
+exports.getPositionWithinBox = boxUtils.getPositionWithinBox;
+exports.isGridLayoutSplitDirection = boxUtils.isGridLayoutSplitDirection;
+exports.pointPositionWithinRect = boxUtils.pointPositionWithinRect;
+exports.Clock = Clock.Clock;
+exports.AggregationType = columnUtils.AggregationType;
+exports.addColumnToSubscribedColumns = columnUtils.addColumnToSubscribedColumns;
+exports.applyDefaultColumnConfig = columnUtils.applyDefaultColumnConfig;
+exports.applyGroupByToColumns = columnUtils.applyGroupByToColumns;
+exports.applyRuntimeColumnWidthsToConfig = columnUtils.applyRuntimeColumnWidthsToConfig;
+exports.applySortToColumns = columnUtils.applySortToColumns;
+exports.applyWidthToColumns = columnUtils.applyWidthToColumns;
+exports.assertAllColumnsAreIncludedInSubscription = columnUtils.assertAllColumnsAreIncludedInSubscription;
+exports.buildColumnMap = columnUtils.buildColumnMap;
+exports.checkConfirmationPending = columnUtils.checkConfirmationPending;
+exports.columnByAriaIndex = columnUtils.columnByAriaIndex;
+exports.dataAndColumnUnchanged = columnUtils.dataAndColumnUnchanged;
+exports.dataColumnAndKeyUnchanged = columnUtils.dataColumnAndKeyUnchanged;
+exports.dataSourceRowToDataRowDto = columnUtils.dataSourceRowToDataRowDto;
+exports.existingSort = columnUtils.existingSort;
+exports.extractGroupColumn = columnUtils.extractGroupColumn;
+exports.findColumn = columnUtils.findColumn;
+exports.flattenColumnGroup = columnUtils.flattenColumnGroup;
+exports.fromServerDataType = columnUtils.fromServerDataType;
+exports.getAllCellsInColumn = columnUtils.getAllCellsInColumn;
+exports.getAriaColIndex = columnUtils.getAriaColIndex;
+exports.getAriaRowIndex = columnUtils.getAriaRowIndex;
+exports.getCalculatedColumnDetails = columnUtils.getCalculatedColumnDetails;
+exports.getColumnLabel = columnUtils.getColumnLabel;
+exports.getColumnName = columnUtils.getColumnName;
+exports.getColumnStyle = columnUtils.getColumnStyle;
+exports.getColumnsInViewport = columnUtils.getColumnsInViewport;
+exports.getDefaultAlignment = columnUtils.getDefaultAlignment;
+exports.getDefaultColumnType = columnUtils.getDefaultColumnType;
+exports.getGroupIcon = columnUtils.getGroupIcon;
+exports.getGroupValue = columnUtils.getGroupValue;
+exports.getPinStateFromElement = columnUtils.getPinStateFromElement;
+exports.getRuntimeColumnWidth = columnUtils.getRuntimeColumnWidth;
+exports.getServerDataType = columnUtils.getServerDataType;
+exports.getTableHeadings = columnUtils.getTableHeadings;
+exports.getTypeFormattingFromColumn = columnUtils.getTypeFormattingFromColumn;
+exports.hasCustomRenderer = columnUtils.hasCustomRenderer;
+exports.hasHeadings = columnUtils.hasHeadings;
+exports.hasValidationRules = columnUtils.hasValidationRules;
+exports.isCalculatedColumn = columnUtils.isCalculatedColumn;
+exports.isColumnTypeRenderer = columnUtils.isColumnTypeRenderer;
+exports.isDataLoading = columnUtils.isDataLoading;
+exports.isDateTimeDataType = columnUtils.isDateTimeDataType;
+exports.isDateTimeDataValue = columnUtils.isDateTimeDataValue;
+exports.isGroupColumn = columnUtils.isGroupColumn;
+exports.isJsonAttribute = columnUtils.isJsonAttribute;
+exports.isJsonColumn = columnUtils.isJsonColumn;
+exports.isJsonGroup = columnUtils.isJsonGroup;
+exports.isLookupRenderer = columnUtils.isLookupRenderer;
+exports.isMappedValueTypeRenderer = columnUtils.isMappedValueTypeRenderer;
+exports.isNanoTimestampColumn = columnUtils.isNanoTimestampColumn;
+exports.isNotHidden = columnUtils.isNotHidden;
+exports.isNumericColumn = columnUtils.isNumericColumn;
+exports.isPinned = columnUtils.isPinned;
+exports.isResizing = columnUtils.isResizing;
+exports.isStringColumn = columnUtils.isStringColumn;
+exports.isTextColumn = columnUtils.isTextColumn;
+exports.isTimeDataType = columnUtils.isTimeDataType;
+exports.isTimeDataValue = columnUtils.isTimeDataValue;
+exports.isTimestampColumn = columnUtils.isTimestampColumn;
+exports.isTypeDescriptor = columnUtils.isTypeDescriptor;
+exports.isValidColumnAlignment = columnUtils.isValidColumnAlignment;
+exports.isValidPinLocation = columnUtils.isValidPinLocation;
+exports.isValueListRenderer = columnUtils.isValueListRenderer;
+exports.isVuuColumnDataType = columnUtils.isVuuColumnDataType;
+exports.mapSortCriteria = columnUtils.mapSortCriteria;
+exports.measurePinnedColumns = columnUtils.measurePinnedColumns;
+exports.metadataKeys = columnUtils.metadataKeys;
+exports.moveColumnTo = columnUtils.moveColumnTo;
+exports.projectUpdates = columnUtils.projectUpdates;
+exports.removeSort = columnUtils.removeSort;
+exports.reorderColumnItems = columnUtils.reorderColumnItems;
+exports.replaceColumn = columnUtils.replaceColumn;
+exports.setAggregations = columnUtils.setAggregations;
+exports.setCalculatedColumnExpression = columnUtils.setCalculatedColumnExpression;
+exports.setCalculatedColumnName = columnUtils.setCalculatedColumnName;
+exports.setCalculatedColumnType = columnUtils.setCalculatedColumnType;
+exports.sortPinnedColumns = columnUtils.sortPinnedColumns;
+exports.subscribedOnly = columnUtils.subscribedOnly;
+exports.toColumnDescriptor = columnUtils.toColumnDescriptor;
+exports.toColumnName = columnUtils.toColumnName;
+exports.toDataSourceColumns = columnUtils.toDataSourceColumns;
+exports.updateColumn = columnUtils.updateColumn;
+exports.updateColumnFormatting = columnUtils.updateColumnFormatting;
+exports.updateColumnRenderProps = columnUtils.updateColumnRenderProps;
+exports.updateColumnType = columnUtils.updateColumnType;
+exports.visibleColumnAtIndex = columnUtils.visibleColumnAtIndex;
+exports.MEASURES = commonTypes.MEASURES;
+exports.getCellConfigPanelRenderer = componentRegistry.getCellConfigPanelRenderer;
+exports.getCellRenderer = componentRegistry.getCellRenderer;
+exports.getCellRendererOptions = componentRegistry.getCellRendererOptions;
+exports.getColumnHeaderContentRenderer = componentRegistry.getColumnHeaderContentRenderer;
+exports.getColumnHeaderLabelRenderer = componentRegistry.getColumnHeaderLabelRenderer;
+exports.getConfigurationEditor = componentRegistry.getConfigurationEditor;
+exports.getEditRuleValidator = componentRegistry.getEditRuleValidator;
+exports.getLayoutComponent = componentRegistry.getLayoutComponent;
+exports.getRegisteredCellRenderers = componentRegistry.getRegisteredCellRenderers;
+exports.getRowClassNameGenerator = componentRegistry.getRowClassNameGenerator;
+exports.isContainer = componentRegistry.isContainer;
+exports.isLayoutComponent = componentRegistry.isLayoutComponent;
+exports.isView = componentRegistry.isView;
+exports.registerComponent = componentRegistry.registerComponent;
+exports.registerConfigurationEditor = componentRegistry.registerConfigurationEditor;
+exports.getCookieValue = cookieUtils.getCookieValue;
+exports.setCookieValue = cookieUtils.setCookieValue;
+exports.importCSS = cssUtils.importCSS;
+exports.DataEditingProvider = DataEditingProvider.DataEditingProvider;
+exports.useEditSession = DataEditingProvider.useEditSession;
+exports.fromRpcEditSessionMode = editUtils.fromRpcEditSessionMode;
+exports.getVuuEditMessage = editUtils.getVuuEditMessage;
+exports.isInlineEditingSession = editUtils.isInlineEditingSession;
+exports.toRpcEditSessionMode = editUtils.toRpcEditSessionMode;
+exports.EditButtons = EditButtons.EditButtons;
+exports.EditSession = EditSession.EditSession;
+exports.StaleUpdateError = EditSession.StaleUpdateError;
+exports.useEditableTable = useEditableTable.useEditableTable;
+exports.DOWN1 = dataUtils.DOWN1;
+exports.DOWN2 = dataUtils.DOWN2;
+exports.UP1 = dataUtils.UP1;
+exports.UP2 = dataUtils.UP2;
+exports.asInteger = dataUtils.asInteger;
+exports.dataDescriptorTypeToVuuRowDataItemType = dataUtils.dataDescriptorTypeToVuuRowDataItemType;
+exports.getMovingValueDirection = dataUtils.getMovingValueDirection;
+exports.isValidNumber = dataUtils.isValidNumber;
+exports.numericTypeOfStringValue = dataUtils.numericTypeOfStringValue;
+exports.shallowEquals = dataUtils.shallowEquals;
+exports.stringIsValidDecimal = dataUtils.stringIsValidDecimal;
+exports.stringIsValidInt = dataUtils.stringIsValidInt;
+exports.stringIsValidLong = dataUtils.stringIsValidLong;
+exports.stringIsValidNumber = dataUtils.stringIsValidNumber;
+exports.BaseDataSource = BaseDataSource.BaseDataSource;
+exports.defaultSuspenseProps = BaseDataSource.defaultSuspenseProps;
+exports.isViewportMenusAction = datasourceActionUtils.isViewportMenusAction;
+exports.isVisualLinkCreatedAction = datasourceActionUtils.isVisualLinkCreatedAction;
+exports.isVisualLinkRemovedAction = datasourceActionUtils.isVisualLinkRemovedAction;
+exports.isVisualLinksAction = datasourceActionUtils.isVisualLinksAction;
+exports.isVuuFeatureAction = datasourceActionUtils.isVuuFeatureAction;
+exports.combineFilters = datasourceFilterUtils.combineFilters;
+exports.NO_CONFIG_CHANGES = datasourceUtils.NO_CONFIG_CHANGES;
+exports.NoFilter = datasourceUtils.NoFilter;
+exports.NoSort = datasourceUtils.NoSort;
+exports.dataSourceRowToEntity = datasourceUtils.dataSourceRowToEntity;
+exports.hasBaseFilter = datasourceUtils.hasBaseFilter;
+exports.hasFilter = datasourceUtils.hasFilter;
+exports.hasGroupBy = datasourceUtils.hasGroupBy;
+exports.hasSort = datasourceUtils.hasSort;
+exports.isBaseFilterChanged = datasourceUtils.isBaseFilterChanged;
+exports.isConfigChanged = datasourceUtils.isConfigChanged;
+exports.isConnectionQualityMetrics = datasourceUtils.isConnectionQualityMetrics;
+exports.isFilterChanged = datasourceUtils.isFilterChanged;
+exports.isGroupByChanged = datasourceUtils.isGroupByChanged;
+exports.isTableSchemaMessage = datasourceUtils.isTableSchemaMessage;
+exports.isTypeaheadSuggestionProvider = datasourceUtils.isTypeaheadSuggestionProvider;
+exports.isViewportMessage = datasourceUtils.isViewportMessage;
+exports.isVisualLinkMessage = datasourceUtils.isVisualLinkMessage;
+exports.isVisualLinksMessage = datasourceUtils.isVisualLinksMessage;
+exports.messageHasDataRows = datasourceUtils.messageHasDataRows;
+exports.messageHasResult = datasourceUtils.messageHasResult;
+exports.messageHasSize = datasourceUtils.messageHasSize;
+exports.stripVisualLink = datasourceUtils.stripVisualLink;
+exports.vanillaConfig = datasourceUtils.vanillaConfig;
+exports.withConfigDefaults = datasourceUtils.withConfigDefaults;
+exports.Time = dateUtils.Time;
+exports.asTimeString = dateUtils.asTimeString;
+exports.decrementTimeUnitValue = dateUtils.decrementTimeUnitValue;
+exports.incrementTimeUnitValue = dateUtils.incrementTimeUnitValue;
+exports.isValidTimeString = dateUtils.isValidTimeString;
+exports.toCalendarDate = dateUtils.toCalendarDate;
+exports.updateTimeString = dateUtils.updateTimeString;
+exports.zeroTime = dateUtils.zeroTime;
+exports.zeroTimeUnit = dateUtils.zeroTimeUnit;
+exports.dateTimePattern = dateTimePattern.dateTimePattern;
+exports.defaultPatternsByType = dateTimePattern.defaultPatternsByType;
+exports.fallbackDateTimePattern = dateTimePattern.fallbackDateTimePattern;
+exports.formatDate = formatter.formatDate;
+exports.getDateFormatter = formatter.getDateFormatter;
+exports.dateTimeLabelByType = types.dateTimeLabelByType;
+exports.isDatePattern = types.isDatePattern;
+exports.isTimePattern = types.isTimePattern;
+exports.supportedDateTimePatterns = types.supportedDateTimePatterns;
+exports.RangeMonitor = debugUtils.RangeMonitor;
+exports.EventEmitter = eventEmitter.EventEmitter;
+exports.assertComponentRegistered = featureUtils.assertComponentRegistered;
+exports.assertComponentsRegistered = featureUtils.assertComponentsRegistered;
+exports.byModule = featureUtils.byModule;
+exports.env = featureUtils.env;
+exports.featureFromJson = featureUtils.featureFromJson;
+exports.getCustomAndTableFeatures = featureUtils.getCustomAndTableFeatures;
+exports.getFilterTableFeatures = featureUtils.getFilterTableFeatures;
+exports.hasFilterTableFeatureProps = featureUtils.hasFilterTableFeatureProps;
+exports.isCustomFeature = featureUtils.isCustomFeature;
+exports.isSameTable = featureUtils.isSameTable;
+exports.isStaticFeatures = featureUtils.isStaticFeatures;
+exports.isVuuTables = featureUtils.isVuuTables;
+exports.isWildcardSchema = featureUtils.isWildcardSchema;
+exports.applyFilterToColumns = filterUtils.applyFilterToColumns;
+exports.extractFilterForColumn = filterUtils.extractFilterForColumn;
+exports.filtersAreEqual = filterUtils.filtersAreEqual;
+exports.getColumnValueFromFilter = filterUtils.getColumnValueFromFilter;
+exports.isAndFilter = filterUtils.isAndFilter;
+exports.isBetweenFilter = filterUtils.isBetweenFilter;
+exports.isBetweenOperator = filterUtils.isBetweenOperator;
+exports.isCompleteFilter = filterUtils.isCompleteFilter;
+exports.isExtendedFilter = filterUtils.isExtendedFilter;
+exports.isFilter = filterUtils.isFilter;
+exports.isFilterClause = filterUtils.isFilterClause;
+exports.isFilteredColumn = filterUtils.isFilteredColumn;
+exports.isInFilter = filterUtils.isInFilter;
+exports.isMultiClauseFilter = filterUtils.isMultiClauseFilter;
+exports.isMultiValueFilter = filterUtils.isMultiValueFilter;
+exports.isNamedFilter = filterUtils.isNamedFilter;
+exports.isOrFilter = filterUtils.isOrFilter;
+exports.isScaledDecimalFilterClause = filterUtils.isScaledDecimalFilterClause;
+exports.isSerializableFilter = filterUtils.isSerializableFilter;
+exports.isSingleValueFilter = filterUtils.isSingleValueFilter;
+exports.isValidFilterClauseOp = filterUtils.isValidFilterClauseOp;
+exports.stripFilterFromColumns = filterUtils.stripFilterFromColumns;
+exports.ONE_DAY_IN_MILLIS = filterAsQuery.ONE_DAY_IN_MILLIS;
+exports.dateFilterAsQuery = filterAsQuery.dateFilterAsQuery;
+exports.filterAsQuery = filterAsQuery.filterAsQuery;
+exports.DataValidationError = formUtils.DataValidationError;
+exports.getFieldName = formUtils.getFieldName;
+exports.getTypedRange = formUtils.getTypedRange;
+exports.getTypedValue = formUtils.getTypedValue;
+exports.isNumber = formUtils.isNumber;
+exports.isValidRange = formUtils.isValidRange;
+exports.defaultValueFormatter = formattingUtils.defaultValueFormatter;
+exports.getValueFormatter = formattingUtils.getValueFormatter;
+exports.lowerCase = formattingUtils.lowerCase;
+exports.numericFormatter = formattingUtils.numericFormatter;
+exports.getUniqueId = getUniqueId.getUniqueId;
+exports.addGroupColumn = groupUtils.addGroupColumn;
+exports.getGroupStatus = groupUtils.getGroupStatus;
+exports.removeGroupColumn = groupUtils.removeGroupColumn;
+exports.createEl = htmlUtils.createEl;
+exports.dispatchCustomEvent = htmlUtils.dispatchCustomEvent;
+exports.dispatchKeyboardEvent = htmlUtils.dispatchKeyboardEvent;
+exports.dispatchMouseEvent = htmlUtils.dispatchMouseEvent;
+exports.focusFirstFocusableElement = htmlUtils.focusFirstFocusableElement;
+exports.getClosest = htmlUtils.getClosest;
+exports.getClosestIndexItem = htmlUtils.getClosestIndexItem;
+exports.getElementByDataIndex = htmlUtils.getElementByDataIndex;
+exports.getElementDataIndex = htmlUtils.getElementDataIndex;
+exports.getFocusableElement = htmlUtils.getFocusableElement;
+exports.getScrollbarSize = htmlUtils.getScrollbarSize;
+exports.hasOpenOptionList = htmlUtils.hasOpenOptionList;
+exports.isDateInput = htmlUtils.isDateInput;
+exports.isInputElement = htmlUtils.isInputElement;
+exports.isSelectableElement = htmlUtils.isSelectableElement;
+exports.queryClosest = htmlUtils.queryClosest;
+exports.isCharacterKey = inputUtils.isCharacterKey;
+exports.isQuoteKey = inputUtils.isQuoteKey;
+exports.invariant = invariant.invariant;
+exports.itemToString = itemToString.itemToString;
+exports.jsonToDataSourceRows = jsonUtils.jsonToDataSourceRows;
+exports.ArrowDown = keyboardUtils.ArrowDown;
+exports.ArrowLeft = keyboardUtils.ArrowLeft;
+exports.ArrowRight = keyboardUtils.ArrowRight;
+exports.ArrowUp = keyboardUtils.ArrowUp;
+exports.End = keyboardUtils.End;
+exports.Enter = keyboardUtils.Enter;
+exports.Escape = keyboardUtils.Escape;
+exports.Home = keyboardUtils.Home;
+exports.PageDown = keyboardUtils.PageDown;
+exports.PageUp = keyboardUtils.PageUp;
+exports.Space = keyboardUtils.Space;
+exports.Tab = keyboardUtils.Tab;
+exports.isArrowKey = keyboardUtils.isArrowKey;
+exports.KeySet = keyset.KeySet;
+exports.getSelectedOption = listUtils.getSelectedOption;
+exports.clearLocalEntity = localStorageUtils.clearLocalEntity;
+exports.getAllLocalEntity = localStorageUtils.getAllLocalEntity;
+exports.getLocalEntity = localStorageUtils.getLocalEntity;
+exports.saveLocalEntity = localStorageUtils.saveLocalEntity;
+exports.getLoggingConfigForWorker = loggingUtils.getLoggingConfigForWorker;
+exports.logUnhandledMessage = loggingUtils.logUnhandledMessage;
+exports.logger = loggingUtils.logger;
+exports.isModule = moduleUtils.isModule;
+exports.uuid = index$2.uuid;
+exports.debounce = perfUtils.debounce;
+exports.throttle = perfUtils.throttle;
+exports.DeferredPromise = promiseUtils.DeferredPromise;
+exports.INVALID_SESSION = protocolMessageUtils.INVALID_SESSION;
+exports.INVALID_TOKEN = protocolMessageUtils.INVALID_TOKEN;
+exports.SESSION_LIMIT_EXCEEDED = protocolMessageUtils.SESSION_LIMIT_EXCEEDED;
+exports.TOKEN_EXPIRED = protocolMessageUtils.TOKEN_EXPIRED;
+exports.hasViewPortContext = protocolMessageUtils.hasViewPortContext;
+exports.isActionMessage = protocolMessageUtils.isActionMessage;
+exports.isAddRowRpcRequest = protocolMessageUtils.isAddRowRpcRequest;
+exports.isBeginEditSessionRpcRequest = protocolMessageUtils.isBeginEditSessionRpcRequest;
+exports.isCreateVpSuccess = protocolMessageUtils.isCreateVpSuccess;
+exports.isCustomComponentActionMessage = protocolMessageUtils.isCustomComponentActionMessage;
+exports.isDeleteSelectedRowsRpcRequest = protocolMessageUtils.isDeleteSelectedRowsRpcRequest;
+exports.isEditCellRpcRequest = protocolMessageUtils.isEditCellRpcRequest;
+exports.isEndEditSessionRpcRequest = protocolMessageUtils.isEndEditSessionRpcRequest;
+exports.isErrorMessage = protocolMessageUtils.isErrorMessage;
+exports.isLoginErrorMessage = protocolMessageUtils.isLoginErrorMessage;
+exports.isLoginResponse = protocolMessageUtils.isLoginResponse;
+exports.isNumericType = protocolMessageUtils.isNumericType;
+exports.isOpenDialogAction = protocolMessageUtils.isOpenDialogAction;
+exports.isOpenSessionTableDialogMessage = protocolMessageUtils.isOpenSessionTableDialogMessage;
+exports.isRequestResponse = protocolMessageUtils.isRequestResponse;
+exports.isRpcError = protocolMessageUtils.isRpcError;
+exports.isRpcServiceRequest = protocolMessageUtils.isRpcServiceRequest;
+exports.isRpcSuccess = protocolMessageUtils.isRpcSuccess;
+exports.isSelectRequest = protocolMessageUtils.isSelectRequest;
+exports.isSelectSuccessWithRowCount = protocolMessageUtils.isSelectSuccessWithRowCount;
+exports.isSessionTable = protocolMessageUtils.isSessionTable;
+exports.isSessionTableActionMessage = protocolMessageUtils.isSessionTableActionMessage;
+exports.isTypeaheadRequest = protocolMessageUtils.isTypeaheadRequest;
+exports.isUndoRowChangeRpcRequest = protocolMessageUtils.isUndoRowChangeRpcRequest;
+exports.isVuuMenuRpcRequest = protocolMessageUtils.isVuuMenuRpcRequest;
+exports.NULL_RANGE = rangeUtils.NULL_RANGE;
+exports.Range = rangeUtils.Range;
+exports.WindowRange = rangeUtils.WindowRange;
+exports.getFullRange = rangeUtils.getFullRange;
+exports.rangeNewItems = rangeUtils.rangeNewItems;
+exports.withinRange = rangeUtils.withinRange;
+exports.asReactElements = reactUtils.asReactElements;
+exports.createSyntheticEvent = reactUtils.createSyntheticEvent;
+exports.isSimpleStateValue = reactUtils.isSimpleStateValue;
+exports.useIsMounted = reactUtils.useIsMounted;
+exports.useStableReference = reactUtils.useStableReference;
+exports.exceedsMaxSafeInteger = roundDecimal.exceedsMaxSafeInteger;
+exports.roundDecimal = roundDecimal.roundDecimal;
+exports.roundScaledDecimal = roundDecimal.roundScaledDecimal;
+exports.actualRowPositioning = rowUtils.actualRowPositioning;
+exports.asDataSourceRowObject = rowUtils.asDataSourceRowObject;
+exports.virtualRowPositioning = rowUtils.virtualRowPositioning;
+exports.vuuRowToDataSourceRow = rowUtils.vuuRowToDataSourceRow;
+exports.ScaledDecimal = ScaledDecimal.ScaledDecimal;
+exports.ScaledDecimal2 = ScaledDecimal.ScaledDecimal2;
+exports.ScaledDecimal4 = ScaledDecimal.ScaledDecimal4;
+exports.ScaledDecimal6 = ScaledDecimal.ScaledDecimal6;
+exports.ScaledDecimal8 = ScaledDecimal.ScaledDecimal8;
+exports.deselectItem = selectionUtils.deselectItem;
+exports.selectItem = selectionUtils.selectItem;
+exports.VuuShellLocation = shellLayoutTypes.VuuShellLocation;
+exports.addSortColumn = sortUtils.addSortColumn;
+exports.getSortStatus = sortUtils.getSortStatus;
+exports.setSortColumn = sortUtils.setSortColumn;
+exports.toggleOrApplySort = sortUtils.toggleOrApplySort;
+exports.getVuuTable = tableSchemaUtils.getVuuTable;
+exports.lastWord = textUtils.lastWord;
+exports.wordify = textUtils.wordify;
+exports.DEFAULT_DENSITY = ThemeProvider.DEFAULT_DENSITY;
+exports.DEFAULT_THEME = ThemeProvider.DEFAULT_THEME;
+exports.DEFAULT_THEME_MODE = ThemeProvider.DEFAULT_THEME_MODE;
+exports.ThemeContext = ThemeProvider.ThemeContext;
+exports.ThemeProvider = ThemeProvider.ThemeProvider;
+exports.useThemeAttributes = ThemeProvider.useThemeAttributes;
+exports.dropLastPathSegment = treeUtils.dropLastPathSegment;
+exports.getParentRow = treeUtils.getParentRow;
+exports.lastPathSegment = treeUtils.lastPathSegment;
+exports.missingAncestor = treeUtils.missingAncestor;
+exports.treeToDataSourceRows = treeUtils.treeToDataSourceRows;
+exports.elementImplementsJSONSerialization = tsUtils.elementImplementsJSONSerialization;
+exports.isNotNullOrUndefined = tsUtils.isNotNullOrUndefined;
+exports.isObject = tsUtils.isObject;
+exports.NO_DATA_MATCH = typeaheadUtils.NO_DATA_MATCH;
+exports.getUrlParameter = urlUtils.getUrlParameter;
+exports.hasUrlParameter = urlUtils.hasUrlParameter;
+exports.useId = useId.useId;
+exports.useLayoutEffectSkipFirst = useLayoutEffectSkipFirst.useLayoutEffectSkipFirst;
+exports.WidthHeight = useResizeObserver.WidthHeight;
+exports.WidthOnly = useResizeObserver.WidthOnly;
+exports.useResizeObserver = useResizeObserver.useResizeObserver;
+exports.useStateRef = useStateRef.useStateRef;
+exports.DataContext = DataContext.DataContext;
+exports.DataProvider = DataProvider.DataProvider;
+exports.useData = DataProvider.useData;
+exports.DataSourceProvider = DataSourceProvider.DataSourceProvider;
+exports.useDataSource = DataSourceProvider.useDataSource;
+exports.WorkspaceContext = WorkspaceContext.WorkspaceContext;
+exports.usePlaceholderJSON = WorkspaceContext.usePlaceholderJSON;
+exports.PageVisibilityObserver = PageVisibilityObserver.PageVisibilityObserver;
+exports.ShellContext = ShellContext.ShellContext;
+exports.useShellContext = ShellContext.useShellContext;
+exports.ThemeLoadChecker = themeUtils.ThemeLoadChecker;
+//# sourceMappingURL=index.js.map

package/cjs/packages/vuu-utils/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/cjs/packages/vuu-utils/src/input-utils.js

@@ -0,0 +1,10 @@
+'use strict';
+
+const isCharacterKey = (key) => key.length === 1;
+const isQuoteKey = (evt) => {
+  return evt.key === '"' || evt.key === "'";
+};
+
+exports.isCharacterKey = isCharacterKey;
+exports.isQuoteKey = isQuoteKey;
+//# sourceMappingURL=input-utils.js.map

package/cjs/packages/vuu-utils/src/input-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-utils.js","sources":["../../../../../../packages/vuu-utils/src/input-utils.ts"],"sourcesContent":["export const isCharacterKey = (key: string) => key.length === 1;\n\nexport const isQuoteKey = (evt: KeyboardEvent) => {\n  return evt.key === '\"' || evt.key === \"'\";\n};\n"],"names":[],"mappings":";;AAAO,MAAM,cAAiB,GAAA,CAAC,GAAgB,KAAA,GAAA,CAAI,MAAW,KAAA;AAEjD,MAAA,UAAA,GAAa,CAAC,GAAuB,KAAA;AAChD,EAAA,OAAO,GAAI,CAAA,GAAA,KAAQ,GAAO,IAAA,GAAA,CAAI,GAAQ,KAAA,GAAA;AACxC;;;;;"}

package/cjs/packages/vuu-utils/src/invariant.js

@@ -0,0 +1,13 @@
+'use strict';
+
+function invariant(condition, message) {
+  if (!condition) {
+    const error = new Error(message);
+    error.name = "Invariant Violation";
+    error.framesToPop = 1;
+    throw error;
+  }
+}
+
+exports.invariant = invariant;
+//# sourceMappingURL=invariant.js.map

package/cjs/packages/vuu-utils/src/invariant.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"invariant.js","sources":["../../../../../../packages/vuu-utils/src/invariant.ts"],"sourcesContent":["export function invariant(condition: boolean, message: string) {\n  if (!condition) {\n    const error = new Error(message);\n    error.name = \"Invariant Violation\";\n    // TODO what is framesToPop?\n    // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n    // @ts-ignore\n    error.framesToPop = 1; // we don't care about invariant's own frame\n    throw error;\n  }\n}\n"],"names":[],"mappings":";;AAAgB,SAAA,SAAA,CAAU,WAAoB,OAAiB,EAAA;AAC7D,EAAA,IAAI,CAAC,SAAW,EAAA;AACd,IAAM,MAAA,KAAA,GAAQ,IAAI,KAAA,CAAM,OAAO,CAAA;AAC/B,IAAA,KAAA,CAAM,IAAO,GAAA,qBAAA;AAIb,IAAA,KAAA,CAAM,WAAc,GAAA,CAAA;AACpB,IAAM,MAAA,KAAA;AAAA;AAEV;;;;"}

package/cjs/packages/vuu-utils/src/itemToString.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const isPlainObject = (obj) => Object.prototype.toString.call(obj) === "[object Object]";
+function itemToString(item) {
+  if (typeof item === "string") {
+    return item;
+  } else if (!isPlainObject(item)) {
+    return String(item);
+  }
+  if (Object.prototype.hasOwnProperty.call(item, "label")) {
+    return String(item.label);
+  }
+  console.warn(
+    [
+      "itemToString: you've likely forgotten to set the label prop on the item object.",
+      "You can also provide your own `itemToString` implementation."
+    ].join("\n")
+  );
+  return "";
+}
+
+exports.itemToString = itemToString;
+//# sourceMappingURL=itemToString.js.map

package/cjs/packages/vuu-utils/src/itemToString.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"itemToString.js","sources":["../../../../../../packages/vuu-utils/src/itemToString.ts"],"sourcesContent":["// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type ItemToStringFunction = (item: any) => string;\n\nconst isPlainObject = (obj: unknown) =>\n  Object.prototype.toString.call(obj) === \"[object Object]\";\n\nexport function itemToString(item: unknown): string {\n  if (typeof item === \"string\") {\n    return item;\n  } else if (!isPlainObject(item)) {\n    return String(item);\n  }\n\n  if (Object.prototype.hasOwnProperty.call(item, \"label\")) {\n    return String((item as { label?: string }).label);\n  }\n\n  console.warn(\n    [\n      \"itemToString: you've likely forgotten to set the label prop on the item object.\",\n      \"You can also provide your own `itemToString` implementation.\",\n    ].join(\"\\n\")\n  );\n\n  return \"\";\n}\n"],"names":[],"mappings":";;AAGA,MAAM,aAAA,GAAgB,CAAC,GACrB,KAAA,MAAA,CAAO,UAAU,QAAS,CAAA,IAAA,CAAK,GAAG,CAAM,KAAA,iBAAA;AAEnC,SAAS,aAAa,IAAuB,EAAA;AAClD,EAAI,IAAA,OAAO,SAAS,QAAU,EAAA;AAC5B,IAAO,OAAA,IAAA;AAAA,GACE,MAAA,IAAA,CAAC,aAAc,CAAA,IAAI,CAAG,EAAA;AAC/B,IAAA,OAAO,OAAO,IAAI,CAAA;AAAA;AAGpB,EAAA,IAAI,OAAO,SAAU,CAAA,cAAA,CAAe,IAAK,CAAA,IAAA,EAAM,OAAO,CAAG,EAAA;AACvD,IAAO,OAAA,MAAA,CAAQ,KAA4B,KAAK,CAAA;AAAA;AAGlD,EAAQ,OAAA,CAAA,IAAA;AAAA,IACN;AAAA,MACE,iFAAA;AAAA,MACA;AAAA,KACF,CAAE,KAAK,IAAI;AAAA,GACb;AAEA,EAAO,OAAA,EAAA;AACT;;;;"}

package/cjs/packages/vuu-utils/src/json-utils.js

@@ -0,0 +1,105 @@
+'use strict';
+
+var columnUtils = require('./column-utils.js');
+
+const { COUNT } = columnUtils.metadataKeys;
+const isJsonData = (value) => typeof value === "object" && value !== null;
+const vuuRowDataItemTypes = ["boolean", "number", "string"];
+const isVuuRowDataItem = (value) => vuuRowDataItemTypes.includes(typeof value);
+const getCellValue = (attribute, attributeValue) => {
+  if (Array.isArray(attributeValue)) {
+    return {
+      attribute: `${attribute}[`,
+      attributeValue: "",
+      isLeaf: false
+    };
+  } else if (isJsonData(attributeValue)) {
+    return {
+      attribute: `${attribute}{`,
+      attributeValue: "",
+      isLeaf: false
+    };
+  } else if (attributeValue === void 0) {
+    return {
+      attribute,
+      attributeValue: "undefined",
+      isLeaf: true
+    };
+  } else if (isVuuRowDataItem(attributeValue)) {
+    return {
+      attribute,
+      attributeValue,
+      isLeaf: true
+    };
+  } else {
+    throw Error(`unsupported type ${typeof attributeValue} in JSON`);
+  }
+};
+const jsonColumnType = {
+  name: "json",
+  renderer: {
+    name: "json"
+  }
+};
+const jsonToDataSourceRows = (json) => {
+  const cols = [];
+  cols.push(
+    {
+      className: "vuuJsonCell",
+      name: "Level 1",
+      type: jsonColumnType
+    },
+    {
+      className: "vuuJsonCell",
+      name: "Level 2",
+      type: jsonColumnType
+    }
+  );
+  const rows = [];
+  addChildValues(rows, json, cols);
+  return [cols, rows];
+};
+const addChildValues = (rows, json, cols, index = { value: 0 }, keyBase = "$root", depth = 0) => {
+  let leafCount = 0;
+  let rowCount = 0;
+  if (depth === cols.length - 1) {
+    cols.push({
+      className: "vuuJsonCell",
+      name: `Level ${cols.length + 1}`,
+      hidden: true,
+      type: jsonColumnType
+    });
+  }
+  const columnEntries = Object.entries(json);
+  for (let i = 0; i < columnEntries.length; i++, index.value += 1) {
+    const [key, value] = columnEntries[i];
+    const { attribute, attributeValue, isLeaf } = getCellValue(key, value);
+    const blanks = Array(depth).fill("");
+    const fullKey = `${keyBase}|${key}`;
+    const ts = 0;
+    const isNew = false;
+    const row = [index.value, index.value, isLeaf, false, depth, 0, fullKey, 0, ts, isNew, ...blanks, attribute, attributeValue];
+    rows.push(row);
+    rowCount += 1;
+    if (isJsonData(value)) {
+      const [nestedLeafCount, nestedRowCount] = addChildValues(
+        rows,
+        value,
+        cols,
+        { value: index.value + 1 },
+        fullKey,
+        depth + 1
+      );
+      row[COUNT] = nestedLeafCount;
+      leafCount += nestedLeafCount;
+      rowCount += nestedRowCount;
+      index.value += nestedRowCount;
+    } else {
+      leafCount += 1;
+    }
+  }
+  return [leafCount, rowCount];
+};
+
+exports.jsonToDataSourceRows = jsonToDataSourceRows;
+//# sourceMappingURL=json-utils.js.map