@vc-shell/framework 1.1.35 → 1.1.36

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vc-shell/framework",
-  "version": "1.1.35",
+  "version": "1.1.36",
   "type": "module",
   "main": "./dist/framework.js",
   "types": "./dist/index.d.ts",
@@ -70,9 +70,9 @@
   "devDependencies": {
     "@fullhuman/postcss-purgecss": "^7.0.2",
     "@types/dompurify": "^3.0.5",
-    "@vc-shell/api-client-generator": "^1.1.35",
-    "@vc-shell/config-generator": "^1.1.35",
-    "@vc-shell/ts-config": "^1.1.35",
+    "@vc-shell/api-client-generator": "^1.1.36",
+    "@vc-shell/config-generator": "^1.1.36",
+    "@vc-shell/ts-config": "^1.1.36",
     "@vitejs/plugin-vue": "^5.2.3",
     "@vue/test-utils": "^2.4.5",
     "cypress-signalr-mock": "^1.5.0",

package/shared/components/notifications/composables/useContainer/index.ts

@@ -181,7 +181,9 @@ export function useContainer(): IUseContainer {
 
         if (positionToRemoveFrom) {
           // Remove the notification from the corresponding container
-          _.remove(notificationContainers[positionToRemoveFrom].value, (item) => item.notificationId === id);
+          notificationContainers[positionToRemoveFrom].value = notificationContainers[
+            positionToRemoveFrom
+          ].value.filter((item) => item.notificationId !== id);
 
           // If container is empty and there are no pending notifications for this position - remove it
           const hasPendingForPosition = pending.items.some((item) => item.position === positionToRemoveFrom);
@@ -307,7 +309,9 @@ export function useContainer(): IUseContainer {
           // If the position changes, move the notification between containers
           if (option.position && option.position !== containerPosition) {
             // Remove from current container
-            _.remove(containerToUpdate.value, (item) => item.notificationId === option.notificationId);
+            containerToUpdate.value = containerToUpdate.value.filter(
+              (item) => item.notificationId !== option.notificationId,
+            );
 
             // Create updated notification with new properties
             const updatedNotification = {

package/shared/composables/index.ts

@@ -1,2 +1,3 @@
 export * from "./useMenuExpanded";
 export * from "./useModificationTracker";
+export * from "./useTableSort";

package/shared/composables/useTableSort.ts

@@ -0,0 +1,99 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// framework/composables/useTableSort.ts
+import { ref, computed, Ref, WritableComputedRef } from "vue";
+
+export type ITableSortDirection = "ASC" | "DESC";
+
+export interface TableSortState {
+  property: string | null;
+  direction: ITableSortDirection | null;
+}
+
+export interface UseTableSortOptions {
+  initialProperty?: string;
+  initialDirection?: ITableSortDirection;
+}
+
+export type SortParam = string;
+
+export interface UseTableSortReturn {
+  // State exposed as writable computed or refs for direct v-model or manipulation if needed
+  // Though direct manipulation is less common, usually via handleSortChange
+  currentSort: WritableComputedRef<TableSortState>;
+  sortExpression: Ref<string | undefined>; // e.g., "name:ASC"
+  handleSortChange: (sortParam: SortParam) => void;
+  resetSort: () => void;
+}
+
+export function useTableSort(options?: UseTableSortOptions): UseTableSortReturn {
+  const currentSortProperty = ref<string | null>(options?.initialProperty || null);
+  const currentSortDirection = ref<ITableSortDirection | null>(options?.initialDirection || null);
+
+  const currentSort: WritableComputedRef<TableSortState> = computed({
+    get: () => ({
+      property: currentSortProperty.value,
+      direction: currentSortDirection.value,
+    }),
+    set: (newState: TableSortState) => {
+      currentSortProperty.value = newState.property;
+      currentSortDirection.value = newState.direction;
+    },
+  });
+
+  const sortExpression = computed<string | undefined>(() => {
+    if (currentSortProperty.value && currentSortDirection.value) {
+      return `${currentSortProperty.value}:${currentSortDirection.value}`;
+    }
+    return undefined;
+  });
+
+  const handleSortChange = (sortParam: SortParam) => {
+    console.log("[useTableSort] handleSortChange triggered. Received sortParam:", JSON.stringify(sortParam));
+
+    let newSortProperty: string | undefined = undefined;
+    let newSortDirection: ITableSortDirection | undefined = undefined;
+
+    const parts = sortParam.split(":");
+    if (parts.length === 2) {
+      newSortProperty = parts[0];
+      const dir = parts[1].toUpperCase();
+      if (dir === "ASC" || dir === "DESC") {
+        newSortDirection = dir as ITableSortDirection;
+      }
+    } else {
+      newSortProperty = sortParam; // Assume it's just the property name
+    }
+
+    if (newSortProperty) {
+      if (currentSortProperty.value === newSortProperty) {
+        // Clicked on the same column, toggle direction
+        if (newSortDirection) {
+          // If table provided a new direction (e.g. 3-state sort)
+          currentSortDirection.value = newSortDirection;
+        } else {
+          // Toggle existing
+          currentSortDirection.value = currentSortDirection.value === "ASC" ? "DESC" : "ASC";
+        }
+      } else {
+        // Clicked on a new column
+        currentSortProperty.value = newSortProperty;
+        currentSortDirection.value = newSortDirection || "ASC"; // Default to ASC if no direction provided
+      }
+      console.log(`[useTableSort] New sort state: ${currentSortProperty.value}:${currentSortDirection.value}`);
+    } else {
+      console.warn("[useTableSort] Could not determine valid sort property from sortParam:", sortParam);
+    }
+  };
+
+  const resetSort = () => {
+    currentSortProperty.value = options?.initialProperty || null;
+    currentSortDirection.value = options?.initialDirection || null;
+  };
+
+  return {
+    currentSort,
+    sortExpression,
+    handleSortChange,
+    resetSort,
+  };
+}