@webitel/ui-datalist 26.8.3 → 26.8.5

package/types/index.d.ts

@@ -1,4 +1,5 @@
+import { useNestedTableList } from './modules/table/composables/useNestedTableList';
 import { createTableStore } from './modules/table/createTableStore.store';
 import type { DatalistTableHeader } from './modules/types/tableStore.types';
 export type { DatalistTableHeader };
-export { createTableStore };
+export { createTableStore, useNestedTableList };

package/types/modules/card/composables/useCardRouting.d.ts

@@ -1,18 +1,22 @@
-import { type Ref } from 'vue';
-import type { CardItemId } from '../types/CardStore.types';
+import { type MaybeRefOrGetter, type Ref } from 'vue';
+import type { CardItemId, CardParentId } from '../types/CardStore.types';
 /**
  * Routing logic shared by top-level and nested card components.
  *
  * - `routeParamName` — which `route.params` key holds the item ID (default: `'id'`)
  * - `parentId` — when provided, the card is treated as nested: URL is updated
- *   only when a newly created item receives its server-assigned ID
+ *   only when a newly created item receives its server-assigned ID. Pass a ref
+ *   or a getter whenever the parent can be created while the card is already
+ *   mounted — a popup living inside its parent's card page watches
+ *   `route.params.id` go from `'new'` to a real id underneath it, and a plain
+ *   string captured at setup would keep addressing `'new'`.
  */
-export declare const useCardRouting: ({ itemId, routeParamName, parentId, manualSetup, }: {
+export declare const useCardRouting: ({ itemId, routeParamName, parentId: rawParentId, manualSetup, }: {
     itemId: Ref<CardItemId>;
     routeParamName?: string;
-    parentId?: string;
+    parentId?: MaybeRefOrGetter<CardParentId>;
     manualSetup?: boolean;
 }) => {
     routeId: import("vue").ComputedRef<any>;
-    parentId: string | undefined;
+    parentId: import("vue").ComputedRef<string | number | null | undefined>;
 };

package/types/modules/card/composables/useCardStoreProvider.d.ts

@@ -0,0 +1,18 @@
+import { type InjectionKey } from 'vue';
+import type { CardItemId, NestedList } from '../types/CardStore.types';
+/**
+ * What a nested tab needs from the card page it lives in: the record it is a
+ * tab of, and somewhere to register its list so the card can empty it.
+ */
+export interface NestedListsOwner {
+    itemId: CardItemId;
+    registerNestedList: (list: NestedList) => void;
+}
+export declare const CardStoreKey: InjectionKey<NestedListsOwner>;
+/**
+ * `useCardComponent` provides the card's own store, so the tabs below it need
+ * no wiring of their own — see `useNestedTableList`.
+ */
+export declare const provideCardStore: (store: NestedListsOwner) => void;
+/** `null` outside a card page, where a list has no owner to reset it */
+export declare const useInjectedCardStore: () => NestedListsOwner | null;

package/types/modules/card/composables/useNestedCardComponent.d.ts

@@ -1,10 +1,14 @@
 import { type StoreDefinition } from 'pinia';
+import { type MaybeRefOrGetter } from 'vue';
+import type { CardParentId } from '../types/CardStore.types';
 /**
  * Composable for nested (popup) card components.
  *
  * Wraps `useCardComponent` with `manualSetup: true` and delegates
  * routing to `useCardRouting`. Pass `parentId` from the component —
- * its presence indicates a nested card context.
+ * its presence indicates a nested card context. A ref or getter is read on
+ * every `initialize`, so a popup mounted while its parent was still `'new'`
+ * follows the parent's real id instead of addressing `'new'` forever.
  *
  * @example
  * ```ts
@@ -21,7 +25,7 @@ export declare const useNestedCardComponent: <CardEntity extends Record<string,
     useCardStore: StoreDefinition;
     onLoadErrorHandler?: (err: unknown) => void;
     routeParamName: string;
-    parentId?: string;
+    parentId?: MaybeRefOrGetter<CardParentId>;
 }) => {
     modelValue: import("vue").ComputedRef<import("@regle/core").JoinDiscriminatedUnions<import("vue").UnwrapNestedRefs<CardEntity>> | import("@regle/schemas").RegleSchemaStatus<CardEntity, {}, true>["$value"]>;
     debouncedIsLoading: Readonly<import("vue").Ref<any, any>>;

package/types/modules/card/index.d.ts

@@ -1,6 +1,7 @@
 export * from './composables/useCardAnyFieldEditedWatcher';
 export * from './composables/useCardComponent';
 export * from './composables/useCardListNavigation';
+export * from './composables/useCardStoreProvider';
 export * from './composables/useCardTabs';
 export * from './composables/useNestedCardComponent';
 export * from './stores/createCardStore';

package/types/modules/card/stores/createCardStore.d.ts

@@ -2,7 +2,7 @@ import { type RegleSchemaBehaviourOptions } from '@regle/schemas';
 import type { ApiModule } from '@webitel/ui-sdk/src/api/types/ApiModule';
 import type { MaybeRef } from 'vue';
 import type { z } from 'zod/v4';
-import type { CardItemId } from '../types/CardStore.types';
+import type { CardItemId, CardParentId, NestedList } from '../types/CardStore.types';
 export declare const createCardStore: <Entity extends {
     id?: string | number;
 } = {
@@ -27,10 +27,11 @@ export declare const createCardStore: <Entity extends {
     error: import("vue").Ref<unknown, unknown>;
     initialize: ({ itemId: initialItemId, parentId: initialParentId, }?: {
         itemId?: string | number;
-        parentId?: string | number;
+        parentId?: CardParentId;
     }) => Promise<void>;
     saveItem: (draft: Entity) => Promise<void>;
     $reset: () => void;
+    registerNestedList: (list: NestedList) => void;
 }, keyof ({
     parentId: import("vue").Ref<CardItemId | undefined, CardItemId | undefined>;
     itemId: import("vue").Ref<CardItemId | undefined, CardItemId | undefined>;
@@ -42,10 +43,11 @@ export declare const createCardStore: <Entity extends {
     error: import("vue").Ref<unknown, unknown>;
     initialize: ({ itemId: initialItemId, parentId: initialParentId, }?: {
         itemId?: string | number;
-        parentId?: string | number;
+        parentId?: CardParentId;
     }) => Promise<void>;
     saveItem: (draft: Entity) => Promise<void>;
     $reset: () => void;
+    registerNestedList: (list: NestedList) => void;
 } extends infer T ? { [K in keyof T as {
     parentId: import("vue").Ref<CardItemId | undefined, CardItemId | undefined>;
     itemId: import("vue").Ref<CardItemId | undefined, CardItemId | undefined>;
@@ -57,10 +59,11 @@ export declare const createCardStore: <Entity extends {
     error: import("vue").Ref<unknown, unknown>;
     initialize: ({ itemId: initialItemId, parentId: initialParentId, }?: {
         itemId?: string | number;
-        parentId?: string | number;
+        parentId?: CardParentId;
     }) => Promise<void>;
     saveItem: (draft: Entity) => Promise<void>;
     $reset: () => void;
+    registerNestedList: (list: NestedList) => void;
 }[K] extends import("pinia")._Method | import("vue").ComputedRef<any> ? never : K]: any; } : never)>, Pick<{
     parentId: import("vue").Ref<CardItemId | undefined, CardItemId | undefined>;
     itemId: import("vue").Ref<CardItemId | undefined, CardItemId | undefined>;
@@ -72,10 +75,11 @@ export declare const createCardStore: <Entity extends {
     error: import("vue").Ref<unknown, unknown>;
     initialize: ({ itemId: initialItemId, parentId: initialParentId, }?: {
         itemId?: string | number;
-        parentId?: string | number;
+        parentId?: CardParentId;
     }) => Promise<void>;
     saveItem: (draft: Entity) => Promise<void>;
     $reset: () => void;
+    registerNestedList: (list: NestedList) => void;
 }, keyof ({
     parentId: import("vue").Ref<CardItemId | undefined, CardItemId | undefined>;
     itemId: import("vue").Ref<CardItemId | undefined, CardItemId | undefined>;
@@ -87,10 +91,11 @@ export declare const createCardStore: <Entity extends {
     error: import("vue").Ref<unknown, unknown>;
     initialize: ({ itemId: initialItemId, parentId: initialParentId, }?: {
         itemId?: string | number;
-        parentId?: string | number;
+        parentId?: CardParentId;
     }) => Promise<void>;
     saveItem: (draft: Entity) => Promise<void>;
     $reset: () => void;
+    registerNestedList: (list: NestedList) => void;
 } extends infer T_1 ? { [K_1 in keyof T_1 as {
     parentId: import("vue").Ref<CardItemId | undefined, CardItemId | undefined>;
     itemId: import("vue").Ref<CardItemId | undefined, CardItemId | undefined>;
@@ -102,10 +107,11 @@ export declare const createCardStore: <Entity extends {
     error: import("vue").Ref<unknown, unknown>;
     initialize: ({ itemId: initialItemId, parentId: initialParentId, }?: {
         itemId?: string | number;
-        parentId?: string | number;
+        parentId?: CardParentId;
     }) => Promise<void>;
     saveItem: (draft: Entity) => Promise<void>;
     $reset: () => void;
+    registerNestedList: (list: NestedList) => void;
 }[K_1] extends import("vue").ComputedRef<any> ? K_1 : never]: any; } : never)>, Pick<{
     parentId: import("vue").Ref<CardItemId | undefined, CardItemId | undefined>;
     itemId: import("vue").Ref<CardItemId | undefined, CardItemId | undefined>;
@@ -117,10 +123,11 @@ export declare const createCardStore: <Entity extends {
     error: import("vue").Ref<unknown, unknown>;
     initialize: ({ itemId: initialItemId, parentId: initialParentId, }?: {
         itemId?: string | number;
-        parentId?: string | number;
+        parentId?: CardParentId;
     }) => Promise<void>;
     saveItem: (draft: Entity) => Promise<void>;
     $reset: () => void;
+    registerNestedList: (list: NestedList) => void;
 }, keyof ({
     parentId: import("vue").Ref<CardItemId | undefined, CardItemId | undefined>;
     itemId: import("vue").Ref<CardItemId | undefined, CardItemId | undefined>;
@@ -132,10 +139,11 @@ export declare const createCardStore: <Entity extends {
     error: import("vue").Ref<unknown, unknown>;
     initialize: ({ itemId: initialItemId, parentId: initialParentId, }?: {
         itemId?: string | number;
-        parentId?: string | number;
+        parentId?: CardParentId;
     }) => Promise<void>;
     saveItem: (draft: Entity) => Promise<void>;
     $reset: () => void;
+    registerNestedList: (list: NestedList) => void;
 } extends infer T_2 ? { [K_2 in keyof T_2 as {
     parentId: import("vue").Ref<CardItemId | undefined, CardItemId | undefined>;
     itemId: import("vue").Ref<CardItemId | undefined, CardItemId | undefined>;
@@ -147,8 +155,9 @@ export declare const createCardStore: <Entity extends {
     error: import("vue").Ref<unknown, unknown>;
     initialize: ({ itemId: initialItemId, parentId: initialParentId, }?: {
         itemId?: string | number;
-        parentId?: string | number;
+        parentId?: CardParentId;
     }) => Promise<void>;
     saveItem: (draft: Entity) => Promise<void>;
     $reset: () => void;
+    registerNestedList: (list: NestedList) => void;
 }[K_2] extends import("pinia")._Method ? K_2 : never]: any; } : never)>>;

package/types/modules/card/types/CardStore.types.d.ts

@@ -1,2 +1,9 @@
 export type CardItemId = string | number | null;
 export type CardParentId = CardItemId;
+/**
+ * What a card store needs from the list of one of its nested tabs: the ability
+ * to empty it when the card page goes away.
+ */
+export interface NestedList {
+    $reset: () => void;
+}

package/types/modules/filter-presets/stores/createFilterPresetsStore.d.ts

@@ -4,6 +4,7 @@ export declare const filterPresetsStoreBody: (namespace?: string) => {
     setupPresetPersistence: () => Promise<void>;
     resetPreset: () => Promise<void>;
     isStoreSetUp: import("vue").Ref<boolean, boolean>;
+    isNested: import("vue").Ref<boolean, boolean>;
     dataList: import("vue").Ref<EnginePresetQuery[], EnginePresetQuery[]>;
     selected: import("vue").Ref<EnginePresetQuery[], EnginePresetQuery[]>;
     error: import("vue").Ref<unknown, unknown>;
@@ -132,6 +133,7 @@ export declare const filterPresetsStoreBody: (namespace?: string) => {
     initialize: ({ parentId: storeParentId, }?: {
         parentId?: string | number;
     }) => Promise<void>;
+    $reset: () => void;
     syncPersistence: () => Promise<void>;
     loadDataList: ({ withLoading, }?: import("../../types/tableStore.types").LoadDataListOptions) => Promise<void>;
     appendToDataList: () => Promise<void>;

package/types/modules/filters/modules/filterConfig/components/case-service/config.d.ts

@@ -4,7 +4,7 @@ export const searchMethod: (params: import("@webitel/api-services/api/clients/_s
 }>;
 export const servicesSearchMethod: (params: Parameters<({ parentId, rootId, ...rest }: {
     parentId?: import("@webitel/api-services/api/clients/_shared/types").ApiId;
-    rootId: import("@webitel/api-services/api/clients/_shared/types").ApiId;
+    rootId?: import("@webitel/api-services/api/clients/_shared/types").ApiId;
 } & import("@webitel/api-services/api/clients/_shared/types").ApiParams) => Promise<{
     items: any;
     next: any;

package/types/modules/permissions-page/stores/createPermissionsStore.d.ts

@@ -13,6 +13,7 @@ export declare const permissionsStoreBody: (namespace: string, config: useTableS
     }) => Promise<void>;
     $reset: () => void;
     isStoreSetUp: import("vue").Ref<boolean, boolean>;
+    isNested: import("vue").Ref<boolean, boolean>;
     dataList: import("vue").Ref<PermissionEntity[], PermissionEntity[]>;
     selected: import("vue").Ref<PermissionEntity[], PermissionEntity[]>;
     error: import("vue").Ref<unknown, unknown>;
@@ -182,6 +183,7 @@ export declare const createPermissionsStore: (namespace: string, config: Omit<us
     }) => Promise<void>;
     $reset: () => void;
     isStoreSetUp: import("vue").Ref<boolean, boolean>;
+    isNested: import("vue").Ref<boolean, boolean>;
     dataList: import("vue").Ref<PermissionEntity[], PermissionEntity[]>;
     selected: import("vue").Ref<PermissionEntity[], PermissionEntity[]>;
     error: import("vue").Ref<unknown, unknown>;

package/types/modules/table/composables/useNestedTableList.d.ts

@@ -0,0 +1,27 @@
+import type { StoreDefinition } from 'pinia';
+import { type MaybeRefOrGetter } from 'vue';
+import type { CardItemId } from '../../card/types/CardStore.types';
+/**
+ * The list of a card page's nested tab.
+ *
+ * The store is shared by every card of its kind and outlives all of them, so a
+ * tab that read it directly showed the rows of whichever record was opened
+ * before — and a card for an unsaved record, having no id to initialize with,
+ * showed them until it was saved.
+ *
+ * Registering the list with the card store makes the card responsible for
+ * emptying it, and the parent to load comes from the card's own `itemId`: it
+ * arrives late for a record created from a nested tab, and the list follows.
+ *
+ * ```ts
+ * const tableStore = useNestedTableList({ useTableStore: useQueueBucketsStore });
+ * const { dataList, isLoading } = storeToRefs(tableStore);
+ * ```
+ *
+ * [WTEL-10350](https://webitel.atlassian.net/browse/WTEL-10350)
+ */
+export declare const useNestedTableList: ({ useTableStore, parentId, }: {
+    useTableStore: StoreDefinition;
+    /** only where the parent is not the card's own record */
+    parentId?: MaybeRefOrGetter<CardItemId>;
+}) => import("pinia").Store<string, import("pinia").StateTree, import("pinia")._GettersTree<import("pinia").StateTree>, import("pinia")._ActionsTree>;

package/types/modules/table/createTableStore.store.d.ts

@@ -3,6 +3,7 @@ import type { Identifiable } from '../types/createDatalistStore.types';
 import type { LoadDataListOptions, PatchItemPropertyParams, useTableStoreConfig } from '../types/tableStore.types';
 export declare const tableStoreBody: <Entity extends Identifiable>(namespace: string, config: useTableStoreConfig<Entity>) => {
     isStoreSetUp: Ref<boolean, boolean>;
+    isNested: Ref<boolean, boolean>;
     dataList: Ref<Entity[], Entity[]>;
     selected: Ref<Entity[], Entity[]>;
     error: Ref<unknown, unknown>;
@@ -131,6 +132,7 @@ export declare const tableStoreBody: <Entity extends Identifiable>(namespace: st
     initialize: ({ parentId: storeParentId, }?: {
         parentId?: string | number;
     }) => Promise<void>;
+    $reset: () => void;
     syncPersistence: () => Promise<void>;
     loadDataList: ({ withLoading, }?: LoadDataListOptions) => Promise<void>;
     appendToDataList: () => Promise<void>;
@@ -163,6 +165,7 @@ export declare const tableStoreBody: <Entity extends Identifiable>(namespace: st
 };
 export declare const createTableStore: <Entity extends Identifiable>(namespace: string, config: useTableStoreConfig<Entity>) => import("../types/createDatalistStore.types").PatchableStoreFactory<{
     isStoreSetUp: Ref<boolean, boolean>;
+    isNested: Ref<boolean, boolean>;
     dataList: Ref<Entity[], Entity[]>;
     selected: Ref<Entity[], Entity[]>;
     error: Ref<unknown, unknown>;
@@ -291,6 +294,7 @@ export declare const createTableStore: <Entity extends Identifiable>(namespace:
     initialize: ({ parentId: storeParentId, }?: {
         parentId?: string | number;
     }) => Promise<void>;
+    $reset: () => void;
     syncPersistence: () => Promise<void>;
     loadDataList: ({ withLoading, }?: LoadDataListOptions) => Promise<void>;
     appendToDataList: () => Promise<void>;