es-application-template 0.0.7

package/dist/management/setting-keys/config-tree/ConfigTreeJsonDrawer.d.ts

@@ -0,0 +1,13 @@
+import { ConfigTreeRow } from './config-tree-value';
+export type ConfigTreeJsonMode = 'VIEW' | 'IMPORT';
+export type ConfigTreeImportMode = 'MERGE' | 'REPLACE';
+type Props = {
+    open: boolean;
+    onClose: () => void;
+    rows: ConfigTreeRow[];
+    mode?: ConfigTreeJsonMode;
+    onApply?: (rows: ConfigTreeRow[]) => void;
+    fileName?: string;
+};
+declare const ConfigTreeJsonDrawer: ({ open, onClose, rows, mode, onApply, fileName }: Props) => import("react/jsx-runtime").JSX.Element;
+export default ConfigTreeJsonDrawer;

package/dist/management/setting-keys/config-tree/ConfigTreeReviewChrome.d.ts

@@ -0,0 +1,4 @@
+import { ConfigTreeRow } from './config-tree-value';
+export declare const ConfigTreeGridFooter: ({ rows }: {
+    rows: ConfigTreeRow[];
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/management/setting-keys/config-tree/ConfigTreeRulesDrawer.d.ts

@@ -0,0 +1,7 @@
+import './ConfigTreeRulesDrawer.scss';
+type Props = {
+    open: boolean;
+    onClose: () => void;
+};
+declare const ConfigTreeRulesDrawer: ({ open, onClose }: Props) => import("react/jsx-runtime").JSX.Element;
+export default ConfigTreeRulesDrawer;

package/dist/management/setting-keys/config-tree/TreeSelect.d.ts

@@ -0,0 +1,10 @@
+import { ConfigFeatureOption } from './config-tree-value';
+import './select-tree.scss';
+type Props = {
+    options: ConfigFeatureOption[];
+    value: string | null;
+    onChange: (value: string | null) => void;
+    placeholder?: string;
+};
+declare const TreeSelect: ({ options, value, onChange, placeholder }: Props) => import("react/jsx-runtime").JSX.Element;
+export default TreeSelect;

package/dist/management/setting-keys/config-tree/config-tree-value.d.ts

@@ -0,0 +1,115 @@
+export type ConfigLeafType = 'string' | 'boolean' | 'number' | 'date' | 'datetime' | 'guid' | 'json';
+/**
+ * `feature` chỉ là metadata của Grid.
+ * Không ghi `feature` vào Config.Value.
+ */
+export type ConfigGridType = ConfigLeafType | 'feature' | '';
+export type ConfigTreeRow = {
+    rowId: string;
+    parentId?: string;
+    key: string;
+    type?: ConfigGridType;
+    value?: unknown;
+    description?: string;
+    children?: ConfigTreeRow[];
+    level?: number;
+};
+export type ConfigFeatureOption = {
+    value: string;
+    label: string;
+    children?: ConfigFeatureOption[];
+};
+export type ConfigTreeValidationError = {
+    rowId?: string;
+    path: string;
+    field: 'key' | 'type' | 'value' | 'tree';
+    message: string;
+};
+export type ParseConfigTreeResult = {
+    rows: ConfigTreeRow[];
+    error?: string;
+};
+export declare const CONFIG_TYPE_OPTIONS: Array<{
+    value: ConfigGridType;
+    label: string;
+}>;
+/**
+ * Khung rỗng tối thiểu của một Feature.
+ *
+ * Chỉ sinh các nhóm để người dùng thêm setting thật:
+ * - ui.list / ui.form
+ * - behavior
+ * - default
+ * - option
+ *
+ * Không sinh key mẫu hoặc value mặc định để tránh lưu nhầm placeholder
+ * hay vô tình thay đổi behavior của Feature. Các nhóm chuẩn là convention,
+ * không phải whitelist; custom key/namespace vẫn được phép.
+ */
+export declare const createMinimalFeatureChildren: () => ConfigTreeRow[];
+/**
+ * Parse riêng cho Import: chỉ nhận đúng document mà tree serializer có thể
+ * round-trip, tránh âm thầm biến primitive/array hoặc leaf sai schema thành {}.
+ */
+export declare const parseConfigImportValueToRows: (value?: string | null) => ParseConfigTreeResult;
+/**
+ * Edit:
+ * - root khác common => type=feature
+ * - group => children, type/value rỗng
+ * - leaf => giữ type/value/description
+ */
+export declare const parseConfigValueToRows: (value?: string | null) => ParseConfigTreeResult;
+export declare const cloneConfigRows: (rows: ConfigTreeRow[]) => ConfigTreeRow[];
+/**
+ * Grid trả dữ liệu paste dưới dạng phẳng và không mang parentId/level.
+ * Khi paste một nhánh vừa copy từ chính Grid vào dòng trống, tìm lại nhánh
+ * nguồn theo các cột đã copy rồi ánh xạ cấu trúc đó sang các rowId mới.
+ */
+export declare const restoreConfigTreePasteHierarchy: (sourceRows: ConfigTreeRow[], pastedRows: ConfigTreeRow[], pastedColumns: string[]) => ConfigTreeRow[];
+/**
+ * Normalize metadata sau callback native của Grid.
+ * Không chứa logic ADD/DELETE/INSERT/DUPLICATE.
+ */
+export declare const normalizeConfigTreeRows: (rows: ConfigTreeRow[]) => ConfigTreeRow[];
+/**
+ * User chọn Type=feature cho một root row do Grid native ADD tạo ra.
+ * Chưa sinh template ở bước này.
+ */
+export declare const markRowAsFeature: (rows: ConfigTreeRow[], rowId: string) => ConfigTreeRow[];
+/**
+ * User chọn Resource.Code ở Key của root type=feature.
+ * Lúc này mới sinh minimal template nếu root chưa có children.
+ */
+export declare const hydrateFeatureRow: (rows: ConfigTreeRow[], rowId: string, feature: ConfigFeatureOption) => ConfigTreeRow[];
+export declare const hasFeatureRoot: (rows: ConfigTreeRow[], featureCode: string, exceptRowId?: string) => boolean;
+/**
+ * Không làm mất root cũ khi Resource API không còn trả Feature đó.
+ */
+export declare const mergeFeatureOptionsWithStoredRoots: (options: ConfigFeatureOption[], rows: ConfigTreeRow[]) => ConfigFeatureOption[];
+export declare const flattenFeatureOptions: (options: ConfigFeatureOption[]) => ConfigFeatureOption[];
+/**
+ * Serialize đúng storage:
+ * - root Feature chỉ là property JSON
+ * - không ghi type=feature
+ * - không schemaVersion
+ * - không settings wrapper
+ * - không ProductCode trong JSON
+ */
+export declare const serializeConfigRowsObject: (rows: ConfigTreeRow[]) => Record<string, unknown>;
+export declare const serializeConfigRows: (rows: ConfigTreeRow[]) => string;
+export declare const serializeConfigRowsPretty: (rows: ConfigTreeRow[]) => string;
+/**
+ * Merge JSON import theo key tree:
+ * - key mới => thêm
+ * - key trùng => dữ liệu import ghi đè node/leaf hiện tại
+ * - key không có trong file import => giữ nguyên
+ */
+export declare const mergeConfigTreeRows: (currentRows: ConfigTreeRow[], importedRows: ConfigTreeRow[]) => ConfigTreeRow[];
+export declare const countConfigNodes: (rows: ConfigTreeRow[]) => number;
+export declare const validateConfigTreeRows: (rows: ConfigTreeRow[]) => ConfigTreeValidationError[];
+export type ConfigTreeImportPreview = {
+    rows: ConfigTreeRow[];
+    errors: string[];
+    ready: boolean;
+};
+export declare const prepareConfigTreeImport: (currentRows: ConfigTreeRow[], importText: string, importMode: "MERGE" | "REPLACE") => ConfigTreeImportPreview;

package/dist/management/setting-keys/index.d.ts

@@ -0,0 +1,2 @@
+declare const SettingsPage: () => import("react/jsx-runtime").JSX.Element;
+export default SettingsPage;

package/dist/management/shortcuts/index.d.ts

@@ -0,0 +1,6 @@
+import './shortcut.scss';
+export type ShortcutsPageProps = {
+    active?: boolean;
+};
+declare const ShortcutsPage: ({ active }: ShortcutsPageProps) => import("react/jsx-runtime").JSX.Element;
+export default ShortcutsPage;

package/dist/management/shortcuts/shortcut-capture-cell.d.ts

@@ -0,0 +1,9 @@
+import { ResolvedShortcutRow, ShortcutActionId, ShortcutBinding } from '../../shortcuts/core/runtime';
+type ShortcutCaptureCellProps = {
+    row: ResolvedShortcutRow;
+    rows: ResolvedShortcutRow[];
+    disabled?: boolean;
+    onChange: (actionId: ShortcutActionId, binding: ShortcutBinding | null) => void;
+};
+declare const ShortcutCaptureCell: ({ row, rows, disabled, onChange }: ShortcutCaptureCellProps) => import("react/jsx-runtime").JSX.Element;
+export default ShortcutCaptureCell;

package/dist/management/shortcuts/shortcut-management-utils.d.ts

@@ -0,0 +1,17 @@
+import { ResolvedShortcutRow, ShortcutActionConfig, ShortcutActionId, ShortcutBinding, ShortcutConfigDocument, ShortcutGroup, ShortcutPlatform } from '../../shortcuts/core/runtime';
+export type ShortcutManagementStatus = 'ALL' | 'ASSIGNED' | 'UNASSIGNED' | 'CUSTOMIZED' | 'INACTIVE' | 'LOCKED' | 'CONFLICT';
+type ShortcutManagementFilters = {
+    keyword: string;
+    group: 'ALL' | ShortcutGroup;
+    status: ShortcutManagementStatus;
+    platform: ShortcutPlatform;
+};
+export declare const patchUserShortcutAction: (overrides: ShortcutConfigDocument["actions"] | undefined, row: ResolvedShortcutRow, patch: ShortcutActionConfig) => ShortcutConfigDocument["actions"];
+export declare const removeUserShortcutAction: (overrides: ShortcutConfigDocument["actions"] | undefined, actionId: ShortcutActionId) => ShortcutConfigDocument["actions"];
+export declare const findShortcutRowsValidationError: (rows: ResolvedShortcutRow[], platform: ShortcutPlatform) => string | null;
+export declare const filterShortcutRows: (rows: ResolvedShortcutRow[], filters: ShortcutManagementFilters) => ResolvedShortcutRow[];
+export type ShortcutBindingPatch = {
+    binding?: ShortcutBinding | null;
+    enabled?: boolean;
+};
+export {};

package/dist/management/shortcuts/use-shortcut-settings-editor.d.ts

@@ -0,0 +1,21 @@
+import { ShortcutConfigDocument } from '../../shortcuts/core/runtime';
+import { IConfigIdentity } from '../../domain/models/IConfig';
+export declare const useShortcutSettingsEditor: (identity: IConfigIdentity) => {
+    value: ShortcutConfigDocument;
+    setValue: (nextValue: ShortcutConfigDocument) => void;
+    save: (nextValue?: ShortcutConfigDocument) => Promise<boolean>;
+    resetAll: () => Promise<boolean>;
+    system: ShortcutConfigDocument;
+    inherited: ShortcutConfigDocument;
+    userStored: ShortcutConfigDocument;
+    effective: ShortcutConfigDocument;
+    ready: boolean;
+    loading: boolean;
+    fetching: boolean;
+    error: Error;
+    retry: () => Promise<void>;
+    saving: boolean;
+    resetting: boolean;
+    dirty: boolean;
+    dataMode: string;
+};

package/dist/package/index.d.ts

@@ -0,0 +1,9 @@
+import '../styles.scss';
+export { AppProvider } from '../runtime/AppProvider';
+export { SHORTCUT_ACTION, Shortcuts, useShortcutHint } from '../shortcuts/core';
+export type { ShortcutActionId, ShortcutActions } from '../shortcuts/core';
+export { ShortcutTooltip } from '../shortcuts/runtime/ShortcutTooltip';
+export { ShortcutOverlayScope } from '../shortcuts/core/advanced';
+export { setting } from '../settings/core/setting';
+export { default as SettingsPage } from '../management/setting-keys';
+export { default as ShortcutsPage } from '../management/shortcuts';

package/dist/runtime/AppProvider.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from 'react';
+type AppProviderProps = {
+    children: ReactNode;
+    dashboardPath?: string;
+    shortcutSettingsPath?: string;
+    onSearch?: () => void;
+};
+export declare const AppProvider: ({ children, dashboardPath, shortcutSettingsPath, onSearch }: AppProviderProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/settings/core/setting-reader.d.ts

@@ -0,0 +1,10 @@
+import { SettingDocument, SettingReader } from './types';
+type InternalSettingReader = SettingReader & {
+    has: (key: string) => boolean;
+};
+export type SettingRegistry = {
+    forResource: (resourceCode: string) => InternalSettingReader;
+};
+export declare const createSettingRegistry: (document?: SettingDocument) => SettingRegistry;
+export declare const createSettingReader: (document: SettingDocument, resourceCode: string) => InternalSettingReader;
+export type { InternalSettingReader };

package/dist/settings/core/setting.d.ts

@@ -0,0 +1,5 @@
+import { SettingDocument, SettingReader } from './types';
+export declare const setSettingDocument: (document?: SettingDocument) => void;
+type SettingAccessor = Pick<SettingReader, 'get'>;
+export declare const setting: SettingAccessor;
+export {};

package/dist/settings/core/types.d.ts

@@ -0,0 +1,14 @@
+export type SettingLeafType = 'string' | 'boolean' | 'number' | 'date' | 'datetime' | 'guid' | 'json';
+export type SettingLeaf<T = unknown> = {
+    type?: SettingLeafType | string;
+    value: T;
+    description?: string;
+};
+export type SettingDocument = Record<string, unknown>;
+export type SettingReader = {
+    resourceCode: string;
+    get: {
+        <T>(key: string): T | undefined;
+        <T>(key: string, fallback: T): T;
+    };
+};

package/dist/settings/runtime/SettingRuntime.d.ts

@@ -0,0 +1,4 @@
+import { ReactNode } from 'react';
+export declare const SettingRuntime: ({ children }: {
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/settings/runtime/use-setting-document.d.ts

@@ -0,0 +1,5 @@
+import { SettingDocument } from '../core/types';
+export declare const useSettingDocument: () => {
+    document: SettingDocument;
+    ready: boolean;
+};

package/dist/shortcuts/core/ShortcutProvider.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+import { ShortcutActionId } from './constants';
+import { ShortcutDomPolicyOverride } from './shortcut-dom-policy';
+import { ShortcutConfigDocument } from './types';
+export type ShortcutProviderProps = {
+    children: ReactNode;
+    config?: ShortcutConfigDocument;
+    domPolicy?: ShortcutDomPolicyOverride;
+    fallbackExecutor?: (actionId: ShortcutActionId) => boolean;
+};
+/**
+ * Portable keyboard runtime. Loading config/identity belongs to the product
+ * product integration layer (for example the package ShortcutRuntime).
+ */
+export declare const ShortcutProvider: ({ children, config, domPolicy, fallbackExecutor }: ShortcutProviderProps) => import("react/jsx-runtime").JSX.Element;

package/dist/shortcuts/core/ShortcutScopes.d.ts

@@ -0,0 +1,16 @@
+import { HTMLAttributes, ReactNode } from 'react';
+import { ShortcutCommandMap } from './shortcut-command';
+export type ShortcutLogicalScopeProps = {
+    children: ReactNode;
+    commands?: ShortcutCommandMap;
+    active?: boolean;
+};
+export type ShortcutDomScopeProps = Omit<HTMLAttributes<HTMLDivElement>, 'children'> & ShortcutLogicalScopeProps;
+export type ShortcutOverlayScopeProps = Omit<ShortcutLogicalScopeProps, 'active'> & {
+    active: boolean;
+};
+export declare const ShortcutPageScope: (props: ShortcutLogicalScopeProps) => import("react/jsx-runtime").JSX.Element;
+export declare const ShortcutOverlayScope: (props: ShortcutOverlayScopeProps) => import("react/jsx-runtime").JSX.Element;
+export declare const ShortcutGridScope: import("react").ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "children"> & ShortcutLogicalScopeProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const ShortcutFormScope: import("react").ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "children"> & ShortcutLogicalScopeProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const ShortcutControlScope: import("react").ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "children"> & ShortcutLogicalScopeProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/shortcuts/core/Shortcuts.d.ts

@@ -0,0 +1,16 @@
+import { ShortcutActionId } from './constants';
+import { ShortcutCommand } from './shortcut-command';
+import { ShortcutHandler } from './registry';
+export type ShortcutActionHandler = ShortcutHandler | ShortcutCommand;
+export type ShortcutActions = Partial<Record<ShortcutActionId, ShortcutActionHandler>>;
+export type ShortcutsProps = {
+    actions?: ShortcutActions;
+};
+/**
+ * Feature-facing shortcut API.
+ *
+ * Feature code only declares semantic Action -> Handler (+ Enabled when needed).
+ * Keyboard bindings, context resolution, owner tracking and overlay barriers stay
+ * inside Shortcut Core.
+ */
+export declare const Shortcuts: ({ actions }: ShortcutsProps) => import("react/jsx-runtime").JSX.Element;

package/dist/shortcuts/core/advanced.d.ts

@@ -0,0 +1,4 @@
+export { ShortcutCommands, useGlobalShortcutCommand, useShortcutCommand } from './shortcut-command';
+export type { ShortcutCommand, ShortcutCommandMap, UseShortcutCommandOptions } from './shortcut-command';
+export { ShortcutControlScope, ShortcutFormScope, ShortcutGridScope, ShortcutOverlayScope, ShortcutPageScope } from './ShortcutScopes';
+export type { ShortcutDomScopeProps, ShortcutLogicalScopeProps, ShortcutOverlayScopeProps } from './ShortcutScopes';

package/dist/shortcuts/core/conflict.d.ts

@@ -0,0 +1,14 @@
+import { ShortcutActionId } from './constants';
+import { ResolvedShortcutRow, ShortcutBinding } from './types';
+export type ShortcutConflict = {
+    item: ResolvedShortcutRow;
+    severity: 'error';
+};
+/**
+ * Catalog shortcut là catalog ACTION CHUNG.
+ *
+ * Một tổ hợp chỉ được ánh xạ tới một actionId trên toàn hệ thống.
+ * `Primary` được kiểm tra trên Windows/macOS/Linux để cùng một config không
+ * trở nên mơ hồ khi người dùng đổi thiết bị.
+ */
+export declare const findShortcutConflict: (rows: ResolvedShortcutRow[], actionId: ShortcutActionId, binding: ShortcutBinding) => ShortcutConflict | null;

package/dist/shortcuts/core/constants.d.ts

@@ -0,0 +1,58 @@
+export declare const SHORTCUT_SCHEMA_VERSION: 4;
+export declare const SHORTCUT_ACTION: {
+    readonly GLOBAL_SEARCH: "global.search";
+    readonly GLOBAL_DASHBOARD: "global.dashboard";
+    readonly GLOBAL_SHORTCUTS: "global.shortcuts";
+    readonly RECORD_CREATE: "record.create";
+    readonly RECORD_VIEW: "record.view";
+    readonly RECORD_EDIT: "record.edit";
+    readonly RECORD_DELETE: "record.delete";
+    readonly RECORD_COPY: "record.copy";
+    readonly RECORD_SELECT_ALL: "record.select-all";
+    readonly LIST_SEARCH: "list.search";
+    readonly LIST_FILTER: "list.filter";
+    readonly LIST_CLEAR_FILTER: "list.clear-filter";
+    readonly GRID_REFRESH: "grid.refresh";
+    readonly HISTORY_VIEW: "history.view";
+    readonly GRID_INSERT_BEFORE: "grid.insert-before";
+    readonly GRID_INSERT_AFTER: "grid.insert-after";
+    readonly GRID_INSERT_CHILD: "grid.insert-child";
+    readonly GRID_DELETE_ALL: "grid.delete-all";
+    readonly GRID_MOVE_UP: "grid.move-up";
+    readonly GRID_MOVE_DOWN: "grid.move-down";
+    readonly GRID_COLUMN_CHOOSER: "grid.column-chooser";
+    readonly GRID_GROUP: "grid.group";
+    readonly GRID_FULLSCREEN: "grid.fullscreen";
+    readonly GRID_EXPAND_ALL: "grid.expand-all";
+    readonly GRID_COLLAPSE_ALL: "grid.collapse-all";
+    readonly FORM_SAVE: "form.save";
+    readonly FORM_SAVE_CLOSE: "form.save-close";
+    readonly FORM_RESET: "form.reset";
+    readonly OVERLAY_CLOSE: "overlay.close";
+    readonly DIALOG_CONFIRM: "dialog.confirm";
+    readonly DATA_IMPORT: "data.import";
+    readonly DATA_EXPORT: "data.export";
+    readonly EXPORT_EXCEL: "export.excel";
+    readonly EXPORT_PDF: "export.pdf";
+    readonly DOCUMENT_PRINT: "document.print";
+    readonly FILE_UPLOAD: "file.upload";
+    readonly FILE_DOWNLOAD: "file.download";
+    readonly FILE_ATTACH: "file.attach";
+    readonly DATA_DOWNLOAD_TEMPLATE: "data.download-template";
+    readonly WORKFLOW_SUBMIT: "workflow.submit";
+    readonly WORKFLOW_HANDLE: "workflow.handle";
+    readonly WORKFLOW_APPROVE: "workflow.approve";
+    readonly WORKFLOW_REJECT: "workflow.reject";
+    readonly WORKFLOW_CANCEL: "workflow.cancel";
+    readonly WORKFLOW_RECALL: "workflow.recall";
+    readonly WORKFLOW_VIEW_PROCESS: "workflow.view-process";
+    readonly WORKFLOW_RESET_PROCESS: "workflow.reset-process";
+    readonly WORKFLOW_COMMENT: "workflow.comment";
+    readonly WORKFLOW_VIEW_COMMENTS: "workflow.view-comments";
+    readonly WORKFLOW_LOCK: "workflow.lock";
+    readonly WORKFLOW_UNLOCK: "workflow.unlock";
+    readonly WORKFLOW_FINISH: "workflow.finish";
+    readonly WORKFLOW_TRANSFER: "workflow.transfer";
+    readonly COMMUNICATION_SEND_EMAIL: "communication.send-email";
+};
+export type ShortcutActionId = typeof SHORTCUT_ACTION[keyof typeof SHORTCUT_ACTION];

package/dist/shortcuts/core/defaults.d.ts

@@ -0,0 +1,8 @@
+import { ShortcutAction, ShortcutConfigDocument, ShortcutGroup } from './types';
+export declare const shortcutGroupLabels: Record<ShortcutGroup, string>;
+export declare const shortcutGroupOptions: {
+    value: string;
+    label: string;
+}[];
+export declare const shortcutActions: ShortcutAction[];
+export declare const shortcutConfigDefaults: ShortcutConfigDocument;

package/dist/shortcuts/core/index.d.ts

@@ -0,0 +1,8 @@
+export { Shortcuts } from './Shortcuts';
+export type { ShortcutActionHandler, ShortcutActions, ShortcutsProps } from './Shortcuts';
+export { SHORTCUT_ACTION } from './constants';
+export type { ShortcutActionId } from './constants';
+export { formatShortcutBinding } from './shortcut-binding';
+export { useShortcutBinding, useShortcutHint } from './use-shortcut-binding';
+export type { ShortcutHint } from './use-shortcut-binding';
+export type { ShortcutBinding, ShortcutModifier } from './types';

package/dist/shortcuts/core/key-normalizer.d.ts

@@ -0,0 +1,15 @@
+import { ShortcutBinding } from './types';
+export declare const bindingKey: (binding?: ShortcutBinding | null) => string;
+export declare const bindingEquals: (left?: ShortcutBinding | null, right?: ShortcutBinding | null) => boolean;
+export declare const shortcutBindingFromEvent: (event: KeyboardEvent) => ShortcutBinding | null;
+export declare const normalizeShortcutText: (value: string) => string;
+export declare const shortcutFromKeyboardEvent: (event: KeyboardEvent) => string;
+export declare const isEditableTarget: (target: EventTarget | null, productSelector?: string) => boolean;
+export declare const isNativeInteractiveTarget: (target: EventTarget | null) => boolean;
+export declare const isNativeInteractiveBinding: (binding: ShortcutBinding | null) => boolean;
+/**
+ * Returns true when the focused control owns the key before the application
+ * shortcut layer. In particular, Esc must close an open select/menu popup
+ * before it is allowed to close the containing modal.
+ */
+export declare const isNativeShortcutOwned: (target: EventTarget | null, binding: ShortcutBinding | null, productPopupSelector?: string) => boolean;

package/dist/shortcuts/core/migrate.d.ts

@@ -0,0 +1,6 @@
+import { bindingEquals, bindingKey } from './key-normalizer';
+import { ShortcutBinding, ShortcutCatalogItem, ShortcutConfigDocument } from './types';
+export { bindingEquals, bindingKey };
+export declare const normalizeShortcutBindingValue: (value: any) => ShortcutBinding | undefined;
+export declare const legacyShortcutKeysToBinding: (value?: string | null) => ShortcutBinding | undefined;
+export declare const normalizeShortcutDocument: (value: any, catalog: ShortcutCatalogItem[]) => ShortcutConfigDocument;

package/dist/shortcuts/core/registry.d.ts

@@ -0,0 +1,134 @@
+import { ShortcutActionId } from './constants';
+import { ShortcutDomPolicy } from './shortcut-dom-policy';
+export type ShortcutHandlerContext = 'global' | 'workspace' | 'page' | 'grid' | 'form' | 'control' | 'overlay';
+export type ShortcutHandler = (event?: KeyboardEvent) => void | Promise<void>;
+export declare const GLOBAL_SHORTCUT_CONTEXT_ID = "shortcut:global";
+export type ShortcutContextRegistration = {
+    id: string;
+    type: ShortcutHandlerContext;
+    parentId?: string;
+    enabled?: boolean;
+    owner?: Element | null;
+};
+export type ShortcutRegistration = {
+    actionId: ShortcutActionId;
+    contextId: string;
+    priority?: number;
+    enabled?: () => boolean;
+    handler: ShortcutHandler;
+};
+export type ShortcutDispatchOptions = {
+    event?: Event;
+    target?: EventTarget | null;
+    path?: EventTarget[];
+    domPolicy?: ShortcutDomPolicy;
+};
+export type ShortcutDispatchResult = {
+    status: 'handled' | 'blocked' | 'unhandled';
+    consume: boolean;
+    reason?: 'disabled' | 'context-barrier' | 'ambiguous-context' | 'no-handler';
+};
+export type ShortcutRegistrySnapshot = {
+    activeContextIds: string[];
+    barrierContextId?: string;
+    contexts: Array<{
+        id: string;
+        type: ShortcutHandlerContext;
+        parentId?: string;
+        enabled: boolean;
+        activated: boolean;
+        hasOwner: boolean;
+    }>;
+};
+export type ShortcutOwnerContextLease = {
+    contextId: string;
+    release: () => void;
+};
+declare class ShortcutRegistry {
+    private contexts;
+    private entries;
+    private order;
+    private activationOrder;
+    private ownerContextOrder;
+    private ownerContexts;
+    private autoOwnerContextIds;
+    constructor();
+    registerContext(context: ShortcutContextRegistration): () => void;
+    setContextOwner(contextId: string, owner: Element | null): void;
+    activateContext(contextId: string, owner?: Element | null): void;
+    deactivateContext(contextId: string): void;
+    setContextEnabled(contextId: string, enabled: boolean): void;
+    /**
+     * Acquires one stable runtime context for one real DOM owner. Multiple command
+     * registrars inside the same owner share the same context and release it only
+     * when the last registrar unmounts.
+     */
+    acquireOwnerContext(type: Exclude<ShortcutHandlerContext, 'global' | 'workspace'>, owner: Element): ShortcutOwnerContextLease;
+    register(registration: ShortcutRegistration): () => void;
+    /**
+     * Keeps Grid/Control interaction memory in sync with the real DOM owner.
+     * Overlay lifetime is resolved from the visible UI at dispatch time, so a
+     * feature never has to maintain activeModal/activeContext state.
+     */
+    syncActiveContexts(event: Event, domPolicy?: ShortcutDomPolicy): void;
+    private isContextEnabled;
+    private isContextActivated;
+    private isSameOrDescendant;
+    private contextDepth;
+    private getDispatchTarget;
+    private ownerPathIndex;
+    private contextOwnsTarget;
+    private isDocumentRootTarget;
+    /**
+     * A mounted owner is not necessarily part of the active UI. Workspace tabs,
+     * collapsed branches and closed overlays can stay mounted while an ancestor
+     * hides them, so fallback resolution must validate the whole DOM ancestry.
+     */
+    private isVisibleOwner;
+    private isVisibleOverlayElement;
+    /**
+     * Resolves the active route/tab DOM branch from the actual keyboard target.
+     * Fallback is deliberately disabled for targets outside the configured page
+     * boundary (navbar, unrelated portal, etc.) unless a blocking overlay owns
+     * the action.
+     */
+    private pageElementForElement;
+    private pageElementForTarget;
+    private overlayZIndex;
+    /** Returns the blocking UI layer that is actually visible on screen now. */
+    private topVisibleOverlayElement;
+    /** Compatibility path for old semantic OverlayScope registrations. */
+    private topActivatedOverlay;
+    private overlayContextForElement;
+    private contextWithinBarrier;
+    private ownerLeaf;
+    private activeLeaf;
+    private branchNode;
+    private ownerContextsForNode;
+    private appendParentChain;
+    private activeBranch;
+    private resolve;
+    /**
+     * Action-aware fallback for auto DOM contexts. Exact focus/owner resolution
+     * always wins first. Fallback only runs when the active branch has no handler.
+     *
+     * Selection policy:
+     * - never cross the top visible overlay barrier;
+     * - stay inside the current configured page route/tab when the event has a
+     *   concrete target;
+     * - ignore mounted-but-hidden owners;
+     * - prefer the most recently interacted eligible owner;
+     * - otherwise use one unique eligible owner;
+     * - never guess when multiple equally valid owners remain.
+     */
+    private resolveActionFallback;
+    private hasHandlerOutsideBranch;
+    private isEntryEnabled;
+    private execute;
+    dispatch(actionId: ShortcutActionId, options?: ShortcutDispatchOptions): ShortcutDispatchResult;
+    hasExecutableHandler(actionId: ShortcutActionId, options?: ShortcutDispatchOptions): boolean;
+    /** Read-only diagnostics for development tools and integration tests. */
+    getDebugSnapshot(options?: ShortcutDispatchOptions): ShortcutRegistrySnapshot;
+}
+export declare const shortcutRegistry: ShortcutRegistry;
+export {};

package/dist/shortcuts/core/reserved-keys.d.ts

@@ -0,0 +1,9 @@
+import { ShortcutActionId } from './constants';
+import { ShortcutPlatform } from './shortcut-platform';
+import { ShortcutBinding } from './types';
+export declare const getProtectedShortcutActionId: (binding?: ShortcutBinding | null, platform?: ShortcutPlatform) => ShortcutActionId | undefined;
+export declare const isProtectedShortcutBinding: (binding?: ShortcutBinding | null, actionId?: ShortcutActionId, platform?: ShortcutPlatform) => boolean;
+export declare const isReservedShortcutBinding: (binding?: ShortcutBinding | null, actionId?: ShortcutActionId) => boolean;
+export declare const validateShortcutBinding: (binding: ShortcutBinding, actionId: ShortcutActionId) => string | null;
+/** Legacy text validator retained for older callers/import surfaces. */
+export declare const validateShortcutKeys: (value: string) => string | null;

package/dist/shortcuts/core/resolve.d.ts

@@ -0,0 +1,2 @@
+import { ResolvedShortcutRow, ShortcutCatalogItem, ShortcutConfigDocument } from './types';
+export declare const resolveShortcutRows: (catalog: ShortcutCatalogItem[], document: ShortcutConfigDocument, inheritedDocument?: ShortcutConfigDocument) => ResolvedShortcutRow[];

package/dist/shortcuts/core/runtime.d.ts

@@ -0,0 +1,17 @@
+export { ShortcutProvider } from './ShortcutProvider';
+export type { ShortcutProviderProps } from './ShortcutProvider';
+export { DEFAULT_SHORTCUT_DOM_POLICY, resolveShortcutDomPolicy } from './shortcut-dom-policy';
+export type { ShortcutDomPolicy, ShortcutDomPolicyOverride } from './shortcut-dom-policy';
+export { SHORTCUT_SCHEMA_VERSION } from './constants';
+export type { ShortcutActionId } from './constants';
+export { findShortcutConflict } from './conflict';
+export { shortcutActions, shortcutConfigDefaults, shortcutGroupLabels, shortcutGroupOptions } from './defaults';
+export { bindingEquals, normalizeShortcutDocument } from './migrate';
+export { resolveShortcutRows } from './resolve';
+export { isReservedShortcutBinding, validateShortcutBinding, validateShortcutKeys } from './reserved-keys';
+export { formatShortcutBinding, shortcutBindingFromCaptureEvent } from './shortcut-binding';
+export { buildUserShortcutSaveDocument, extractUserOverrides, mergeShortcutActionMaps, mergeShortcutDocuments, parseShortcutConfigValue, parseShortcutImport, resolveRuntimeShortcutDocument } from './shortcut-config';
+export type { ShortcutImportIssue, ShortcutImportIssueCode, ShortcutImportResult } from './shortcut-config';
+export { getShortcutPlatform, SUPPORTED_SHORTCUT_PLATFORMS } from './shortcut-platform';
+export type { ShortcutPlatform } from './shortcut-platform';
+export type { ResolvedShortcutRow, ShortcutAction, ShortcutActionConfig, ShortcutCatalogItem, ShortcutConfigDocument, ShortcutCustomizeMode, ShortcutGroup, ShortcutBinding, ShortcutModifier } from './types';