@wisemen/vue-core-actions 0.1.1

package/dist/locales/en-US.json.d.ts

@@ -0,0 +1,12 @@
+declare const _default: {
+  "action.group.account": "Account",
+  "action.group.developer": "Developer",
+  "action.group.general": "General",
+  "action.group.navigation": "Navigation",
+  "action.group.preferences": "Preferences",
+  "search": "Search...",
+  "type_a_command_or_search": "Type a command or search..."
+}
+;
+
+export default _default;

package/dist/locales/nl-BE.json.d.ts

@@ -0,0 +1,12 @@
+declare const _default: {
+  "action.group.account": "Account",
+  "action.group.developer": "Ontwikkelaar",
+  "action.group.general": "Algemeen",
+  "action.group.navigation": "Navigatie",
+  "action.group.preferences": "Voorkeuren",
+  "search": "Zoeken...",
+  "type_a_command_or_search": "Type een command of zoek..."
+}
+;
+
+export default _default;

package/dist/locales-BPtvPqGa.js

@@ -0,0 +1,22 @@
+var en_US_default = {
+	"action.group.account": "Account",
+	"action.group.developer": "Developer",
+	"action.group.general": "General",
+	"action.group.navigation": "Navigation",
+	"action.group.preferences": "Preferences",
+	search: "Search...",
+	type_a_command_or_search: "Type a command or search..."
+}, nl_BE_default = {
+	"action.group.account": "Account",
+	"action.group.developer": "Ontwikkelaar",
+	"action.group.general": "Algemeen",
+	"action.group.navigation": "Navigatie",
+	"action.group.preferences": "Voorkeuren",
+	search: "Zoeken...",
+	type_a_command_or_search: "Type een command of zoek..."
+};
+const actionsLocales = {
+	"en-US": en_US_default,
+	"nl-BE": nl_BE_default
+};
+export { actionsLocales as t };

package/dist/locales-D5e1O21n.cjs

@@ -0,0 +1 @@
+const e=`Search...`,t=`Type a command or search...`;var n={"action.group.account":`Account`,"action.group.developer":`Developer`,"action.group.general":`General`,"action.group.navigation":`Navigation`,"action.group.preferences":`Preferences`,search:`Search...`,type_a_command_or_search:`Type a command or search...`};const r=`Zoeken...`,i=`Type een command of zoek...`;var a={"action.group.account":`Account`,"action.group.developer":`Ontwikkelaar`,"action.group.general":`Algemeen`,"action.group.navigation":`Navigatie`,"action.group.preferences":`Voorkeuren`,search:`Zoeken...`,type_a_command_or_search:`Type een command of zoek...`};const o={"en-US":n,"nl-BE":a};Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return o}});

package/dist/locales.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./locales-D5e1O21n.cjs`);exports.actionsLocales=e.t;

package/dist/locales.d.ts

@@ -0,0 +1,20 @@
+export declare const actionsLocales: {
+    'en-US': {
+        "action.group.account": string;
+        "action.group.developer": string;
+        "action.group.general": string;
+        "action.group.navigation": string;
+        "action.group.preferences": string;
+        search: string;
+        type_a_command_or_search: string;
+    };
+    'nl-BE': {
+        "action.group.account": string;
+        "action.group.developer": string;
+        "action.group.general": string;
+        "action.group.navigation": string;
+        "action.group.preferences": string;
+        search: string;
+        type_a_command_or_search: string;
+    };
+};

package/dist/locales.js

@@ -0,0 +1,2 @@
+import { t as actionsLocales } from "./locales-BPtvPqGa.js";
+export { actionsLocales };

package/dist/stores/actionManager.store.d.ts

@@ -0,0 +1,82 @@
+import { Action } from '../types/action.type.ts';
+import { ActionContext } from '../types/actionContext.type.ts';
+import { ActionModel } from '../types/actionModel.type.ts';
+interface ActionContextOptions {
+    keyboardEvent?: KeyboardEvent;
+    menuType?: 'commandMenu' | 'contextualMenu';
+    metadata?: Record<string, unknown>;
+    models?: ActionModel[];
+    searchInput?: string;
+    subActionsMeta?: Record<string, number | null>;
+}
+declare function executeAction(action: Action, ctx: ActionContext, options?: {
+    onComplete?: () => void;
+}): Promise<void>;
+export declare const useActionManagerStore: import('pinia').StoreDefinition<"actionManager", Pick<{
+    actionContext: (options: ActionContextOptions) => ActionContext;
+    executeAction: typeof executeAction;
+    focusedModels: import('vue').Ref<{
+        key: string;
+        modelName: string;
+    }[], ActionModel[] | {
+        key: string;
+        modelName: string;
+    }[]>;
+    metadata: import('vue').Ref<Record<string, unknown>, Record<string, unknown>>;
+    registerMetadata: (meta: Record<string, unknown>) => void;
+    setFocusedModels: (models: ActionModel[]) => void;
+    setViewModels: (models: ActionModel[]) => void;
+    unregisterMetadata: (key: string) => void;
+    viewModels: import('vue').Ref<{
+        key: string;
+        modelName: string;
+    }[], ActionModel[] | {
+        key: string;
+        modelName: string;
+    }[]>;
+}, "metadata" | "focusedModels" | "viewModels">, Pick<{
+    actionContext: (options: ActionContextOptions) => ActionContext;
+    executeAction: typeof executeAction;
+    focusedModels: import('vue').Ref<{
+        key: string;
+        modelName: string;
+    }[], ActionModel[] | {
+        key: string;
+        modelName: string;
+    }[]>;
+    metadata: import('vue').Ref<Record<string, unknown>, Record<string, unknown>>;
+    registerMetadata: (meta: Record<string, unknown>) => void;
+    setFocusedModels: (models: ActionModel[]) => void;
+    setViewModels: (models: ActionModel[]) => void;
+    unregisterMetadata: (key: string) => void;
+    viewModels: import('vue').Ref<{
+        key: string;
+        modelName: string;
+    }[], ActionModel[] | {
+        key: string;
+        modelName: string;
+    }[]>;
+}, never>, Pick<{
+    actionContext: (options: ActionContextOptions) => ActionContext;
+    executeAction: typeof executeAction;
+    focusedModels: import('vue').Ref<{
+        key: string;
+        modelName: string;
+    }[], ActionModel[] | {
+        key: string;
+        modelName: string;
+    }[]>;
+    metadata: import('vue').Ref<Record<string, unknown>, Record<string, unknown>>;
+    registerMetadata: (meta: Record<string, unknown>) => void;
+    setFocusedModels: (models: ActionModel[]) => void;
+    setViewModels: (models: ActionModel[]) => void;
+    unregisterMetadata: (key: string) => void;
+    viewModels: import('vue').Ref<{
+        key: string;
+        modelName: string;
+    }[], ActionModel[] | {
+        key: string;
+        modelName: string;
+    }[]>;
+}, "actionContext" | "executeAction" | "registerMetadata" | "setFocusedModels" | "setViewModels" | "unregisterMetadata">>;
+export {};

package/dist/stores/actionRegistry.store.d.ts

@@ -0,0 +1,17 @@
+import { Action } from '../types/action.type.ts';
+export declare const useActionRegistryStore: import('pinia').StoreDefinition<"actionRegistry", Pick<{
+    allActions: () => Action[];
+    registerActions: (...actions: Action[]) => void;
+    registerTemporaryAction: (action: Action) => number;
+    unregisterAction: (id: number) => void;
+}, never>, Pick<{
+    allActions: () => Action[];
+    registerActions: (...actions: Action[]) => void;
+    registerTemporaryAction: (action: Action) => number;
+    unregisterAction: (id: number) => void;
+}, never>, Pick<{
+    allActions: () => Action[];
+    registerActions: (...actions: Action[]) => void;
+    registerTemporaryAction: (action: Action) => number;
+    unregisterAction: (id: number) => void;
+}, "allActions" | "registerActions" | "registerTemporaryAction" | "unregisterAction">>;

package/dist/types/action.type.d.ts

@@ -0,0 +1,225 @@
+import { Component } from 'vue';
+import { Resolvable } from './actionContext.type.ts';
+import { ActionGroup } from './actionGroup.type.ts';
+import { KeyboardShortcut } from './keyboardShortcut.type.ts';
+export interface ActionAvatar {
+    /**
+     * By default, the avatar's background color is generated based on
+     * the provided name to ensure consistency across renders.
+     * Setting this prop to `true` will disable this behavior and
+     * use a static background color instead.
+     */
+    isStaticColor?: boolean;
+    /**
+     * The name used to generate fallback initials.
+     */
+    name: string;
+    /**
+     * The image source URL for the avatar's logo.
+     * Falls back to initials when not provided.
+     * @default null
+     */
+    logo?: string | null;
+    /**
+     * The image source URL for the avatar.
+     * Falls back to initials when not provided.
+     * @default null
+     */
+    src?: string | null;
+}
+export interface SearchSubActionsConfig {
+    maxResults?: number;
+    minLength?: number;
+    placeholder?: (() => string) | string;
+}
+export interface SubActionsWithMeta<TContext = any> {
+    actions: Action<TContext>[];
+    /** Next-page cursor offset. Pass back via `ctx.subActionsMeta` to fetch the next page. `null` = no more pages. */
+    pagination: {
+        nextOffset: number | null;
+    };
+}
+export interface Action<TContext = any> {
+    /**
+     * Stable UUID used for deduplication and keyboard-shortcut registration.
+     * Generated once at definition time (e.g. via crypto.randomUUID()).
+     */
+    id: string;
+    /**
+     * Returns false to hide the action entirely from the menu.
+     * Evaluated once per render cycle.
+     */
+    isApplicable?: (ctx: TContext) => boolean;
+    /**
+     * Primary display name.  May be a static string or a function that reads the
+     * context (e.g. to return "Add" vs "Remove" based on current selection).
+     */
+    name: Resolvable<string, TContext>;
+    /**
+     * When false (default), the action is hidden when the user is not authenticated.
+     * Set to true to keep the action visible on unauthenticated views (e.g. login page).
+     */
+    availableWhenUnauthenticated?: boolean;
+    /**
+     *
+     */
+    avatar?: Resolvable<ActionAvatar, TContext>;
+    /**
+     * Returns a human-readable string explaining why the action is disabled, or
+     * undefined / null if it is enabled.
+     * A disabled action is still visible (greyed out) with the reason as a tooltip.
+     */
+    disabledReason?: (ctx: TContext) => string | null | undefined;
+    /**
+     * Called when the user activates the action.
+     * May return a Promise for async operations.
+     */
+    execute?: (ctx: TContext) => Promise<void> | void;
+    /**
+     * When true is set on an action, it prevents the action from being set
+     * as the parent action when opening its sub-menu
+     */
+    forceAsRootMenu?: boolean;
+    /**
+     * The group this action belongs to.
+     */
+    group?: ActionGroup<TContext>;
+    /**
+     * Short secondary label shown next to the action name (e.g. in the command
+     * menu).  Use this to provide extra context that does not fit in the name —
+     * for example a file path, a record ID, or a status badge.
+     *
+     * May be a static string, `null`, or a function that reads the context.
+     */
+    hint?: Resolvable<string | null, TContext>;
+    /**
+     * Optionally show an icon for the action
+     */
+    icon?: (ctx: TContext) => Component | null;
+    /**
+     * Optional string key used for deduplication when the same logical action is
+     * registered from multiple places.  Only the first registration wins.
+     */
+    key?: string;
+    /**
+     * Keyboard shortcut
+     */
+    keyboardShortcut?: KeyboardShortcut;
+    /**
+     * Extra search terms (not displayed) that boost discoverability.
+     * Matched against the fuzzy query in addition to name.
+     */
+    keywords?: string | string[];
+    /**
+     * Keywords that must be an exact substring match (case-insensitive) to boost
+     * the action score to 1.0.
+     */
+    keywordsExactMatch?: string[];
+    /**
+     * When set to true, the command menu will not close when toggling its sub actions
+     */
+    multiSelectSubActions?: boolean;
+    /**
+     * The name to show in breadcrumbs / parent references when this action is a
+     * parent of a sub-action drill-down.  Falls back to `name` when absent.
+     */
+    nameAsParent?: Resolvable<string, TContext>;
+    /**
+     * The parent action of this action, if it is a sub-action.  Injected automatically when drilling down or lifting.
+     */
+    parentAction?: Action<TContext>;
+    /**
+     * Controls how parent actions influence this action’s fuzzy search score.
+     *
+     * By default, parent metadata (e.g. parent label / context) is included in the
+     * scoring input to improve discoverability of nested actions.
+     *
+     * This option allows you to reduce or fully remove that influence.
+     *
+     * Values:
+     * - 'none' → Parents actions are fully excluded in scoring
+     * - 'direct' → Only the direct parent is included in the scoring
+     * - 'all' → All parent context is included
+     *
+     * @default 'all'
+     */
+    parentScoreInfluence?: 'all' | 'direct' | 'none';
+    /**
+     * Returns a Vue component displayed in a side panel when the user presses
+     * the right arrow key while this action is focused. Useful for showing a
+     * richer preview (e.g. details, metadata, a summary) without leaving the
+     * current menu context.
+     */
+    preview?: (ctx: TContext) => Component | null;
+    /**
+     * The root action of this action, if it is a sub-action.  Injected automatically when drilling down or lifting.
+     */
+    rootAction?: Action<TContext>;
+    /**
+     * Override the computed fuzzy score with a fixed value.
+     * Applied after parent-action penalty and before sortPriority.
+     */
+    scoreOverride?: number;
+    /**
+     * Fine-grained control over how sub-actions are searched and displayed.
+     */
+    searchSubActionsConfig?: Resolvable<SearchSubActionsConfig, TContext>;
+    /**
+     * When resolved to true, a checkmark / selected indicator is shown.
+     * Used for toggle actions.
+     */
+    selected?: Resolvable<boolean, TContext>;
+    /**
+     * Groups this action into a named visual section for context menus and dropdown
+     * menus. A separator is rendered whenever the section key changes between two
+     * adjacent visible actions. Actions without a separatorGroup (or sharing the
+     * same key) are rendered without a separator between them.
+     *
+     * Has no effect when a search query is active.
+     *
+     * @example
+     * // Edit action — no separatorGroup (default section)
+     * // Availability actions — separatorGroup: 'availability'
+     * // Delete action — separatorGroup: 'delete'
+     * // → separator before first availability action and before delete
+     */
+    separatorGroup?: string;
+    /**
+     * Controls whether selected sub-actions are sorted to the top of the list.
+     *
+     * @default true
+     */
+    showSelectedSubActionsFirst?: boolean;
+    /**
+     * When true, this action is always included in results regardless of its fuzzy
+     * score (score is overridden to 1.0 when filtering is skipped).
+     */
+    skipFilterScoring?: boolean;
+    /**
+     * Manual sort offset applied after score-based sorting.
+     * Positive values push the action down; negative values pull it up.
+     */
+    sortPriority?: number;
+    /**
+     * Factory that returns child actions.  When the user selects this action the
+     * menu drills down into the child list.
+     * During a search query, child actions are "lifted" to the top level with
+     * parentAction / rootAction injected.
+     *
+     * May return a `SubActionsWithMeta` wrapper to carry pagination state. The
+     * meta is stored by the host menu and passed back via `ctx.subActionsMeta`
+     * (keyed by this action's id) on subsequent "load more" calls.
+     */
+    subActions?: (ctx: TContext) => Action<TContext>[] | AsyncGenerator<Action<TContext>> | Promise<Action<TContext>[] | SubActionsWithMeta<TContext>> | SubActionsWithMeta<TContext>;
+    /**
+     * When true, keyboard shortcuts defined on sub-actions are registered globally.
+     * The actionShortcuts composable will recursively resolve sub-actions (synchronous
+     * results only) and include their shortcuts in the global hotkey map.
+     */
+    subActionsHaveKeyboardShortcuts?: boolean;
+    /**
+     * When true the action is hidden in the root menu (no search query).
+     * It only appears in search results.
+     */
+    onlyVisibleThroughSearch?: boolean;
+}

package/dist/types/actionContext.type.d.ts

@@ -0,0 +1,112 @@
+import { Router } from 'vue-router';
+import { ActionModel } from './actionModel.type.ts';
+/**
+ * Contextual information available to actions during execution or evaluation.
+ * Provides access to models, routing state, user input, and UI context.
+ *
+ * @template TModelMap - A map of model names to their corresponding types.
+ * @template TRouter - A tuple of route definition objects, each having at least a `name` property.
+ */
+export interface ActionContext<TModelMap = Record<string, ActionModel>, TRoutes extends any[] = any[], TMetadata = any> {
+    /**
+     * Returns the stored pagination offset for a given action id, or `null` if no
+     * offset is stored (initial call) or all pages are exhausted.
+     */
+    getPaginationOffsetForSubActionId: (id: string) => number | null;
+    /**
+     * Returns whether any dialog is currently open and active in the UI.
+     *
+     * @returns `true` if at least one dialog is currently active.
+     */
+    hasActiveDialogs: () => boolean;
+    /**
+     * Returns whether any targeted models of the given type are currently selected.
+     *
+     * @template TModelName - A key of `TModelMap`.
+     * @param modelName - The model type to check for.
+     * @returns `true` if at least one targeted model of the given type exists.
+     */
+    hasTargetedModelsOfType: <TModelName extends keyof TModelMap>(modelName: TModelName) => boolean;
+    /**
+     * Returns whether the specified route is currently active.
+     *
+     * @param routeName - The name of the route to check, constrained to known route names in `TRouter`.
+     * @param exact - When `true`, requires an exact route match rather than a prefix match. Defaults to `false`.
+     * @returns `true` if the route is active.
+     */
+    isRouteActive: (routeName: TRoutes[number]['name'], exact?: boolean) => boolean;
+    /**
+     * All models currently available in the application, regardless of selection or focus state.
+     */
+    allModels: TModelMap[keyof TModelMap][];
+    /**
+     * Models that currently have keyboard or UI focus.
+     * A subset of {@link allModels}.
+     */
+    focusedModels: TModelMap[keyof TModelMap][];
+    /**
+     * The keyboard event that triggered the current action, if any.
+     * Absent when the action was triggered through a non-keyboard interaction.
+     */
+    keyboardEvent?: KeyboardEvent;
+    /**
+     * The type of menu from which the action was invoked, if applicable.
+     *
+     * - `'commandMenu'` — triggered from a command palette or global search menu.
+     * - `'contextualMenu'` — triggered from a right-click or context-sensitive menu.
+     *
+     * Absent when the action was not invoked from a menu.
+     */
+    menuType?: 'commandMenu' | 'contextualMenu';
+    /**
+     * Arbitrary key/value data registered by components via `registerMetadata`.
+     * Typed at the application level by augmenting `TMetadata`.
+     */
+    metadata: TMetadata;
+    /**
+     * The currently targeted (selected) models.
+     * This is the primary set of models the action should operate on.
+     */
+    models: TModelMap[keyof TModelMap][];
+    /**
+     * The application's router state, represented as a tuple of route objects.
+     * Each entry corresponds to a route definition with at least a `name` field.
+     */
+    router: Router;
+    /**
+     * The current search or filter string entered by the user in the active menu.
+     * Empty string when no input has been provided.
+     */
+    searchInput: string;
+    /**
+     * Pagination offsets from previous `subActions` calls, keyed by action id.
+     * Set by the host menu when triggering a "load more" scroll event.
+     * Prefer `getPaginationOffsetForSubActionId` over reading this directly.
+     */
+    subActionsMeta?: Record<string, number | null>;
+    /**
+     * Returns the targeted model filtered to only those matching the given model type.
+     *
+     * @template TModelName - A key of `TModelMap`.
+     * @param modelName - The model type to filter by.
+     * @returns An first targeted model of the specified type, or null
+     */
+    targetedModelOfType: <TModelName extends keyof TModelMap>(modelName: TModelName) => TModelMap[TModelName] | null;
+    /**
+     * Returns the targeted model filtered to only those matching the given model type.
+     *
+     * @template TModelName - A key of `TModelMap`.
+     * @param modelName - The model type to filter by.
+     * @returns An first targeted model of the specified type.
+     */
+    targetedModelOfTypeOrThrow: <TModelName extends keyof TModelMap>(modelName: TModelName) => TModelMap[TModelName];
+    /**
+     * Returns the targeted models filtered to only those matching the given model type.
+     *
+     * @template TModelName - A key of `TModelMap`.
+     * @param modelName - The model type to filter by.
+     * @returns An array of targeted models of the specified type.
+     */
+    targetedModelsOfType: <TModelName extends keyof TModelMap>(modelName: TModelName) => TModelMap[TModelName][];
+}
+export type Resolvable<T, TContext> = ((ctx: TContext) => T) | T;

package/dist/types/actionGroup.type.d.ts

@@ -0,0 +1,19 @@
+import { Component } from 'vue';
+import { ActionContext, Resolvable } from './actionContext.type.ts';
+export interface ActionGroup<TActionContext = any> {
+    name?: Resolvable<string, TActionContext>;
+    category?: Resolvable<string, TActionContext>;
+    /**
+     * When a child action is "lifted" into a top-level search result, its group is
+     * replaced with this one rather than the original group.
+     * Used to keep lifted children in a logical section (e.g. the parent's group).
+     */
+    groupWhenLifted?: ActionGroup<TActionContext>;
+    icon?: (ctx: ActionContext) => Component;
+    priority?: Resolvable<number, TActionContext>;
+    /**
+     * When there's only 1 group in the command menu results, the group label is hidden by default.
+     * When set to true, the label of this group will always be visible, even if there's only 1 group
+     */
+    showIfOnlyGroup?: boolean;
+}

package/dist/types/actionModel.type.d.ts

@@ -0,0 +1,4 @@
+export interface ActionModel {
+    key: string;
+    modelName: string;
+}

package/dist/types/commandMenu.type.d.ts

@@ -0,0 +1,11 @@
+import { Action } from './action.type.ts';
+export interface NavFrame {
+    actions: Action[];
+    parentAction: Action;
+    /** The action that was highlighted when we drilled in (so we can re-focus it on back). */
+    savedActiveAction: Action | null;
+    /** Resolved (filtered) actions at the time we drilled in, so we can restore them instantly on back. */
+    savedResolvedActions: Action[];
+    /** Search query active at the moment we drilled into this frame. */
+    savedSearchInput: string;
+}

package/dist/types/keyboardShortcut.type.d.ts

@@ -0,0 +1,26 @@
+import { HotkeySequence, RawHotkey } from '@tanstack/vue-hotkeys';
+/**
+ * A multi-step key sequence shortcut (e.g. ['g', 's'] — press g then s).
+ * Maps to TanStack's HotkeySequence.
+ */
+export interface SequenceShortcut {
+    /**
+     * When true the shortcut fires even when a text input has focus.
+     * Default: false — shortcuts are suppressed while typing.
+     */
+    runWithInputFocus?: boolean;
+    sequence: HotkeySequence;
+}
+/**
+ * A single-key shortcut (e.g. Mod+S).
+ * Maps directly to TanStack's RawHotkey plus the `runWithInputFocus` flag.
+ */
+export type SingleKeyShortcut = RawHotkey & {
+    /**
+     * When true the shortcut fires even when a text input has focus.
+     * Default: false — shortcuts are suppressed while typing.
+     */
+    runWithInputFocus?: boolean;
+    sequence?: never;
+};
+export type KeyboardShortcut = SequenceShortcut | SingleKeyShortcut;

package/dist/utils/commandMenuGroups.util.d.ts

@@ -0,0 +1,12 @@
+import { Component } from 'vue';
+import { Action } from '../types/action.type.ts';
+import { ActionContext } from '../types/actionContext.type.ts';
+export interface CommandMenuGroup {
+    category: string | null;
+    icon: Component | null;
+    items: Action[];
+    key: string;
+    label: string | null;
+    showIfOnlyGroup: boolean;
+}
+export declare function buildCommandMenuGroups(actions: Action[], ctx: ActionContext): CommandMenuGroup[];

package/dist/utils/resolveActions.util.d.ts

@@ -0,0 +1,13 @@
+import { Component } from 'vue';
+import { Action, ActionAvatar, SearchSubActionsConfig } from '../types/action.type.ts';
+import { ActionContext } from '../types/actionContext.type.ts';
+export type ActionFactory = (() => Action[]) | Action;
+export declare function applicableActions(actions: Action[], ctx: ActionContext, onUpdate?: (partial: Action[]) => void, parentAction?: Action): Promise<Action[]>;
+export declare function resolveApplicable(action: Action, ctx: ActionContext): boolean;
+export declare function resolveActionValue<T>(value: ((ctx: ActionContext) => T) | T, ctx: ActionContext): T;
+export declare function resolveActionName(action: Action, ctx: ActionContext): string;
+export declare function resolveActionAvatar(action: Action, ctx: ActionContext): ActionAvatar | null;
+export declare function resolveActionHint(action: Action, ctx: ActionContext): string | null;
+export declare function resolveActionSelected(action: Action, ctx: ActionContext): boolean | null;
+export declare function resolveSearchSubActionsConfig(action: Action, ctx: ActionContext): SearchSubActionsConfig | null;
+export declare function resolveActionPreview(action: Action, ctx: ActionContext): Component | null;

package/dist/utils/subActions.util.d.ts

@@ -0,0 +1,5 @@
+import { Action, SubActionsWithMeta } from '../types/action.type.ts';
+import { ActionContext } from '../types/actionContext.type.ts';
+export declare function isSubActionsWithMeta(v: unknown): v is SubActionsWithMeta;
+export declare function storeSubActionsPagination(action: Action, result: Action[] | SubActionsWithMeta, subActionsMetaMap: Record<string, number | null>): Action[];
+export declare function resolveSubActions(action: Action, ctx: ActionContext, subActionsMetaMap: Record<string, number | null>, limit?: number): Promise<Action[]>;