@oxy.so/services 11.2.0-oxy-one.3 → 11.2.0-oxy-one.4

package/src/ui/stores/__tests__/followStore.test.ts

@@ -27,10 +27,16 @@ interface FollowServicesMock {
 
 const makeServices = (): { mock: FollowServicesMock; services: OxyServices } => {
   const mock: FollowServicesMock = {
-    follows: { statuses: jest.fn(async (ids: string[]) =>
-      Object.fromEntries(ids.map((id) => [id, false])),
-    ), follow: jest.fn(async () => ({ message: 'ok' })), unfollow: jest.fn(async () => ({ message: 'ok' })) },
-    session: { get userId() { return (jest.fn(() => 'viewer-1'))(); } },
+    follows: {
+      statuses: jest.fn(async (ids: string[]) => Object.fromEntries(ids.map((id) => [id, false]))),
+      follow: jest.fn(async () => ({ message: 'ok' })),
+      unfollow: jest.fn(async () => ({ message: 'ok' })),
+    },
+    session: {
+      get userId() {
+        return jest.fn(() => 'viewer-1')();
+      },
+    },
   };
   return { mock, services: mock as unknown as OxyServices };
 };
@@ -103,7 +109,9 @@ describe('toggleFollowUser (optimistic)', () => {
     const { mock, services } = makeServices();
     let resolveFollow: (value: FollowMutationResult) => void = () => {};
     mock.follows.follow.mockReturnValueOnce(
-      new Promise<FollowMutationResult>((resolve) => { resolveFollow = resolve; }),
+      new Promise<FollowMutationResult>((resolve) => {
+        resolveFollow = resolve;
+      }),
     );
 
     const store = useFollowStore.getState();
@@ -149,7 +157,9 @@ describe('toggleFollowUser (optimistic)', () => {
 
     expect(accepted).toBe(false);
     // The key is removed → back to UNKNOWN (tri-state), not a definite false.
-    expect(Object.prototype.hasOwnProperty.call(useFollowStore.getState().followingUsers, 'u1')).toBe(false);
+    expect(
+      Object.prototype.hasOwnProperty.call(useFollowStore.getState().followingUsers, 'u1'),
+    ).toBe(false);
   });
 });
 
@@ -158,7 +168,10 @@ describe('resetFollowState', () => {
     const { mock, services } = makeServices();
     let resolveBatch: ((value: Record<string, boolean>) => void) | undefined;
     mock.follows.statuses.mockImplementation(
-      () => new Promise<Record<string, boolean>>((resolve) => { resolveBatch = resolve; }),
+      () =>
+        new Promise<Record<string, boolean>>((resolve) => {
+          resolveBatch = resolve;
+        }),
     );
 
     const store = useFollowStore.getState();

package/src/ui/stores/assetStore.ts

@@ -5,21 +5,21 @@ interface AssetState {
   // Asset data
   assets: Record<string, Asset>;
   uploadProgress: Record<string, AssetUploadProgress>;
-  
+
   // Loading states
   loading: {
     uploading: boolean;
     linking: boolean;
     deleting: boolean;
   };
-  
+
   // Error states
   errors: {
     upload?: string;
     link?: string;
     delete?: string;
   };
-  
+
   // Actions
   setAsset: (asset: Asset) => void;
   /**
@@ -29,32 +29,32 @@ interface AssetState {
   mergeAsset: (patch: Partial<Asset> & { id: string }) => void;
   setAssets: (assets: Asset[]) => void;
   removeAsset: (assetId: string) => void;
-  
+
   // Upload progress actions
   setUploadProgress: (fileId: string, progress: AssetUploadProgress) => void;
   removeUploadProgress: (fileId: string) => void;
-  
+
   // Link management
   addLink: (assetId: string, link: AssetLink) => void;
   removeLink: (assetId: string, app: string, entityType: string, entityId: string) => void;
-  
+
   // Loading states
   setUploading: (uploading: boolean) => void;
   setLinking: (linking: boolean) => void;
   setDeleting: (deleting: boolean) => void;
-  
+
   // Error management
   setUploadError: (error?: string) => void;
   setLinkError: (error?: string) => void;
   setDeleteError: (error?: string) => void;
   clearErrors: () => void;
-  
+
   // Utility methods
   getAssetsByApp: (app: string) => Asset[];
   getAssetsByEntity: (app: string, entityType: string, entityId: string) => Asset[];
   getAssetUsageCount: (assetId: string) => number;
   isAssetLinked: (assetId: string, app: string, entityType: string, entityId: string) => boolean;
-  
+
   // Reset store
   reset: () => void;
 }
@@ -71,208 +71,207 @@ const initialState = {
 };
 
 export const useAssetStore = create<AssetState>((set, get) => ({
-    ...initialState,
-    
-    // Asset management
-    setAsset: (asset: Asset) => {
-      set((state) => ({
+  ...initialState,
+
+  // Asset management
+  setAsset: (asset: Asset) => {
+    set((state) => ({
+      assets: {
+        ...state.assets,
+        [asset.id]: asset,
+      },
+    }));
+  },
+
+  mergeAsset: (patch) => {
+    set((state) => ({
+      assets: {
+        ...state.assets,
+        // A partial record stays partial until a full read replaces it.
+        [patch.id]: { ...state.assets[patch.id], ...patch } as Asset,
+      },
+    }));
+  },
+
+  setAssets: (assets: Asset[]) => {
+    set((state) => {
+      const assetMap = assets.reduce(
+        (acc, asset) => {
+          acc[asset.id] = asset;
+          return acc;
+        },
+        {} as Record<string, Asset>,
+      );
+
+      return {
         assets: {
           ...state.assets,
-          [asset.id]: asset,
+          ...assetMap,
         },
-      }));
-    },
-    
-    mergeAsset: (patch) => {
-      set((state) => ({
+      };
+    });
+  },
+
+  removeAsset: (assetId: string) => {
+    set((state) => {
+      const { [assetId]: removed, ...rest } = state.assets;
+      return { assets: rest };
+    });
+  },
+
+  // Upload progress
+  setUploadProgress: (fileId: string, progress: AssetUploadProgress) => {
+    set((state) => ({
+      uploadProgress: {
+        ...state.uploadProgress,
+        [fileId]: progress,
+      },
+    }));
+  },
+
+  removeUploadProgress: (fileId: string) => {
+    set((state) => {
+      const { [fileId]: removed, ...rest } = state.uploadProgress;
+      return { uploadProgress: rest };
+    });
+  },
+
+  // Link management
+  addLink: (assetId: string, link: AssetLink) => {
+    set((state) => {
+      const asset = state.assets[assetId];
+      if (!asset) return state;
+
+      // Check if link already exists
+      const existingLink = asset.links.find(
+        (l: AssetLink) =>
+          l.app === link.app && l.entityType === link.entityType && l.entityId === link.entityId,
+      );
+
+      if (existingLink) return state;
+
+      const updatedAsset = {
+        ...asset,
+        links: [...asset.links, link],
+        usageCount: asset.links.length + 1,
+      };
+
+      return {
         assets: {
           ...state.assets,
-          // A partial record stays partial until a full read replaces it.
-          [patch.id]: { ...state.assets[patch.id], ...patch } as Asset,
+          [assetId]: updatedAsset,
         },
-      }));
-    },
+      };
+    });
+  },
 
-    setAssets: (assets: Asset[]) => {
-      set((state) => {
-        const assetMap = assets.reduce((acc, asset) => {
-          acc[asset.id] = asset;
-          return acc;
-        }, {} as Record<string, Asset>);
-        
-        return {
-          assets: {
-            ...state.assets,
-            ...assetMap,
-          },
-        };
-      });
-    },
-    
-    removeAsset: (assetId: string) => {
-      set((state) => {
-        const { [assetId]: removed, ...rest } = state.assets;
-        return { assets: rest };
-      });
-    },
-    
-    // Upload progress
-    setUploadProgress: (fileId: string, progress: AssetUploadProgress) => {
-      set((state) => ({
-        uploadProgress: {
-          ...state.uploadProgress,
-          [fileId]: progress,
-        },
-      }));
-    },
-    
-    removeUploadProgress: (fileId: string) => {
-      set((state) => {
-        const { [fileId]: removed, ...rest } = state.uploadProgress;
-        return { uploadProgress: rest };
-      });
-    },
-    
-    // Link management
-    addLink: (assetId: string, link: AssetLink) => {
-      set((state) => {
-        const asset = state.assets[assetId];
-        if (!asset) return state;
-        
-        // Check if link already exists
-        const existingLink = asset.links.find(
-          (l: AssetLink) => l.app === link.app && 
-                 l.entityType === link.entityType && 
-                 l.entityId === link.entityId
-        );
-        
-        if (existingLink) return state;
-        
-        const updatedAsset = {
-          ...asset,
-          links: [...asset.links, link],
-          usageCount: asset.links.length + 1,
-        };
-        
-        return {
-          assets: {
-            ...state.assets,
-            [assetId]: updatedAsset,
-          },
-        };
-      });
-    },
-    
-    removeLink: (assetId: string, app: string, entityType: string, entityId: string) => {
-      set((state) => {
-        const asset = state.assets[assetId];
-        if (!asset) return state;
-        
-        const filteredLinks = asset.links.filter(
-          (link: AssetLink) => !(link.app === app && 
-                     link.entityType === entityType && 
-                     link.entityId === entityId)
-        );
-        
-        const updatedAsset = {
-          ...asset,
-          links: filteredLinks,
-          usageCount: filteredLinks.length,
-          status: filteredLinks.length === 0 ? 'trash' as const : asset.status,
-        };
-        
-        return {
-          assets: {
-            ...state.assets,
-            [assetId]: updatedAsset,
-          },
-        };
-      });
-    },
-    
-    // Loading states
-    setUploading: (uploading: boolean) => {
-      set((state) => ({
-        loading: { ...state.loading, uploading },
-      }));
-    },
-    
-    setLinking: (linking: boolean) => {
-      set((state) => ({
-        loading: { ...state.loading, linking },
-      }));
-    },
-    
-    setDeleting: (deleting: boolean) => {
-      set((state) => ({
-        loading: { ...state.loading, deleting },
-      }));
-    },
-    
-    // Error management
-    setUploadError: (error?: string) => {
-      set((state) => ({
-        errors: { ...state.errors, upload: error },
-      }));
-    },
-    
-    setLinkError: (error?: string) => {
-      set((state) => ({
-        errors: { ...state.errors, link: error },
-      }));
-    },
-    
-    setDeleteError: (error?: string) => {
-      set((state) => ({
-        errors: { ...state.errors, delete: error },
-      }));
-    },
-    
-    clearErrors: () => {
-      set({ errors: {} });
-    },
-    
-    // Utility methods
-    getAssetsByApp: (app: string) => {
-      const { assets } = get();
-      return Object.values(assets).filter((asset) =>
-        asset.links.some((link: AssetLink) => link.app === app)
-      );
-    },
-    
-    getAssetsByEntity: (app: string, entityType: string, entityId: string) => {
-      const { assets } = get();
-      return Object.values(assets).filter((asset) =>
-        asset.links.some(
-          (link: AssetLink) => link.app === app && 
-                   link.entityType === entityType && 
-                   link.entityId === entityId
-        )
-      );
-    },
-    
-    getAssetUsageCount: (assetId: string) => {
-      const { assets } = get();
-      const asset = assets[assetId];
-      return asset ? asset.usageCount : 0;
-    },
-    
-    isAssetLinked: (assetId: string, app: string, entityType: string, entityId: string) => {
-      const { assets } = get();
-      const asset = assets[assetId];
-      if (!asset) return false;
-      
-      return asset.links.some(
-        (link: AssetLink) => link.app === app && 
-                 link.entityType === entityType && 
-                 link.entityId === entityId
+  removeLink: (assetId: string, app: string, entityType: string, entityId: string) => {
+    set((state) => {
+      const asset = state.assets[assetId];
+      if (!asset) return state;
+
+      const filteredLinks = asset.links.filter(
+        (link: AssetLink) =>
+          !(link.app === app && link.entityType === entityType && link.entityId === entityId),
       );
-    },
-    
-    // Reset store
-    reset: () => {
-      set(initialState);
-    },
+
+      const updatedAsset = {
+        ...asset,
+        links: filteredLinks,
+        usageCount: filteredLinks.length,
+        status: filteredLinks.length === 0 ? ('trash' as const) : asset.status,
+      };
+
+      return {
+        assets: {
+          ...state.assets,
+          [assetId]: updatedAsset,
+        },
+      };
+    });
+  },
+
+  // Loading states
+  setUploading: (uploading: boolean) => {
+    set((state) => ({
+      loading: { ...state.loading, uploading },
+    }));
+  },
+
+  setLinking: (linking: boolean) => {
+    set((state) => ({
+      loading: { ...state.loading, linking },
+    }));
+  },
+
+  setDeleting: (deleting: boolean) => {
+    set((state) => ({
+      loading: { ...state.loading, deleting },
+    }));
+  },
+
+  // Error management
+  setUploadError: (error?: string) => {
+    set((state) => ({
+      errors: { ...state.errors, upload: error },
+    }));
+  },
+
+  setLinkError: (error?: string) => {
+    set((state) => ({
+      errors: { ...state.errors, link: error },
+    }));
+  },
+
+  setDeleteError: (error?: string) => {
+    set((state) => ({
+      errors: { ...state.errors, delete: error },
+    }));
+  },
+
+  clearErrors: () => {
+    set({ errors: {} });
+  },
+
+  // Utility methods
+  getAssetsByApp: (app: string) => {
+    const { assets } = get();
+    return Object.values(assets).filter((asset) =>
+      asset.links.some((link: AssetLink) => link.app === app),
+    );
+  },
+
+  getAssetsByEntity: (app: string, entityType: string, entityId: string) => {
+    const { assets } = get();
+    return Object.values(assets).filter((asset) =>
+      asset.links.some(
+        (link: AssetLink) =>
+          link.app === app && link.entityType === entityType && link.entityId === entityId,
+      ),
+    );
+  },
+
+  getAssetUsageCount: (assetId: string) => {
+    const { assets } = get();
+    const asset = assets[assetId];
+    return asset ? asset.usageCount : 0;
+  },
+
+  isAssetLinked: (assetId: string, app: string, entityType: string, entityId: string) => {
+    const { assets } = get();
+    const asset = assets[assetId];
+    if (!asset) return false;
+
+    return asset.links.some(
+      (link: AssetLink) =>
+        link.app === app && link.entityType === entityType && link.entityId === entityId,
+    );
+  },
+
+  // Reset store
+  reset: () => {
+    set(initialState);
+  },
 }));
 
 // Selector hooks for convenience
@@ -283,8 +282,7 @@ export const useAssetLoading = () => useAssetStore((state) => state.loading);
 export const useAssetErrors = () => useAssetStore((state) => state.errors);
 
 // Typed selectors for specific use cases
-export const useAssetsByApp = (app: string) => 
-  useAssetStore((state) => state.getAssetsByApp(app));
+export const useAssetsByApp = (app: string) => useAssetStore((state) => state.getAssetsByApp(app));
 
 export const useAssetsByEntity = (app: string, entityType: string, entityId: string) =>
   useAssetStore((state) => state.getAssetsByEntity(app, entityType, entityId));
@@ -292,5 +290,9 @@ export const useAssetsByEntity = (app: string, entityType: string, entityId: str
 export const useAssetUsageCount = (assetId: string) =>
   useAssetStore((state) => state.getAssetUsageCount(assetId));
 
-export const useIsAssetLinked = (assetId: string, app: string, entityType: string, entityId: string) =>
-  useAssetStore((state) => state.isAssetLinked(assetId, app, entityType, entityId));
+export const useIsAssetLinked = (
+  assetId: string,
+  app: string,
+  entityType: string,
+  entityId: string,
+) => useAssetStore((state) => state.isAssetLinked(assetId, app, entityType, entityId));