@semiont/react-ui 0.5.1 → 0.5.2

package/src/features/admin-security/state/__tests__/admin-security-state-unit.test.ts

@@ -0,0 +1,68 @@
+import { describe, it, expect, vi } from 'vitest';
+import { firstValueFrom } from 'rxjs';
+import { filter } from 'rxjs/operators';
+import type { SemiontClient } from '@semiont/sdk';
+import type { ShellStateUnit } from '../../../../state/shell-state-unit';
+import { createAdminSecurityStateUnit } from '../admin-security-state-unit';
+
+function mockBrowse(): ShellStateUnit {
+  return { dispose: vi.fn() } as unknown as ShellStateUnit;
+}
+
+function mockClient(oauthConfig: ReturnType<typeof vi.fn>): SemiontClient {
+  return { admin: { oauthConfig } } as unknown as SemiontClient;
+}
+
+describe('createAdminSecurityStateUnit', () => {
+  it('fetches OAuth config on creation', async () => {
+    const getOAuthConfig = vi.fn().mockResolvedValue({
+      providers: [{ name: 'google' }],
+      allowedDomains: ['example.com'],
+    });
+    const stateUnit = createAdminSecurityStateUnit(mockClient(getOAuthConfig), mockBrowse());
+
+    const providers = await firstValueFrom(stateUnit.providers$.pipe(filter((p) => p.length > 0)));
+    expect(providers).toEqual([{ name: 'google' }]);
+
+    const domains = await firstValueFrom(stateUnit.allowedDomains$.pipe(filter((d) => d.length > 0)));
+    expect(domains).toEqual(['example.com']);
+
+    stateUnit.dispose();
+  });
+
+  it('starts loading, resolves to false', async () => {
+    const stateUnit = createAdminSecurityStateUnit(
+      mockClient(vi.fn().mockResolvedValue({ providers: [], allowedDomains: [] })),
+      mockBrowse(),
+    );
+
+    await firstValueFrom(stateUnit.isLoading$.pipe(filter((l) => !l)));
+    stateUnit.dispose();
+  });
+
+  it('sets loading false on error', async () => {
+    const stateUnit = createAdminSecurityStateUnit(
+      mockClient(vi.fn().mockRejectedValue(new Error('fail'))),
+      mockBrowse(),
+    );
+
+    await firstValueFrom(stateUnit.isLoading$.pipe(filter((l) => !l)));
+    stateUnit.dispose();
+  });
+
+  it('defaults to empty arrays when response has no providers/domains', async () => {
+    const stateUnit = createAdminSecurityStateUnit(
+      mockClient(vi.fn().mockResolvedValue({})),
+      mockBrowse(),
+    );
+
+    await firstValueFrom(stateUnit.isLoading$.pipe(filter((l) => !l)));
+
+    const providers = await firstValueFrom(stateUnit.providers$);
+    const domains = await firstValueFrom(stateUnit.allowedDomains$);
+    expect(providers).toEqual([]);
+    expect(domains).toEqual([]);
+
+    stateUnit.dispose();
+  });
+});

package/src/features/admin-security/state/admin-security-state-unit.ts

@@ -0,0 +1,46 @@
+import { BehaviorSubject, type Observable } from 'rxjs';
+import { createDisposer } from '@semiont/sdk';
+import type { StateUnit } from '@semiont/sdk';
+import type { ShellStateUnit } from '../../../state/shell-state-unit';
+import type { SemiontClient } from '@semiont/sdk';
+
+export interface AdminSecurityStateUnit extends StateUnit {
+  browse: ShellStateUnit;
+  providers$: Observable<unknown[]>;
+  allowedDomains$: Observable<string[]>;
+  isLoading$: Observable<boolean>;
+}
+
+export function createAdminSecurityStateUnit(
+  client: SemiontClient,
+  browse: ShellStateUnit,
+): AdminSecurityStateUnit {
+  const disposer = createDisposer();
+  disposer.add(browse);
+
+  const providers$ = new BehaviorSubject<unknown[]>([]);
+  const allowedDomains$ = new BehaviorSubject<string[]>([]);
+  const isLoading$ = new BehaviorSubject<boolean>(true);
+
+  client.admin!.oauthConfig()
+    .then((data) => {
+      const config = data as { providers?: unknown[]; allowedDomains?: string[] };
+      providers$.next(config.providers ?? []);
+      allowedDomains$.next(config.allowedDomains ?? []);
+      isLoading$.next(false);
+    })
+    .catch(() => isLoading$.next(false));
+
+  return {
+    browse,
+    providers$: providers$.asObservable(),
+    allowedDomains$: allowedDomains$.asObservable(),
+    isLoading$: isLoading$.asObservable(),
+    dispose: () => {
+      providers$.complete();
+      allowedDomains$.complete();
+      isLoading$.complete();
+      disposer.dispose();
+    },
+  };
+}

package/src/features/admin-users/components/AdminUsersPage.tsx

@@ -6,7 +6,7 @@
  */
 
 import React, { useState } from 'react';
-import { COMMON_PANELS, type ToolbarPanelType } from '@semiont/sdk';
+import { COMMON_PANELS, type ToolbarPanelType } from '../../../state/shell-state-unit';
 import {
   PlusIcon,
   MagnifyingGlassIcon,

package/src/features/admin-users/state/__tests__/admin-users-state-unit.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect, vi } from 'vitest';
+import { firstValueFrom } from 'rxjs';
+import { filter } from 'rxjs/operators';
+import type { SemiontClient } from '@semiont/sdk';
+import type { ShellStateUnit } from '../../../../state/shell-state-unit';
+import { createAdminUsersStateUnit } from '../admin-users-state-unit';
+
+function mockBrowse(): ShellStateUnit {
+  return { dispose: vi.fn() } as unknown as ShellStateUnit;
+}
+
+function mockClient(overrides: {
+  listUsers?: ReturnType<typeof vi.fn>;
+  getUserStats?: ReturnType<typeof vi.fn>;
+  updateUser?: ReturnType<typeof vi.fn>;
+} = {}): SemiontClient {
+  return {
+    admin: {
+      users: overrides.listUsers ?? vi.fn().mockResolvedValue({ users: [] }),
+      userStats: overrides.getUserStats ?? vi.fn().mockResolvedValue({ stats: null }),
+      updateUser: overrides.updateUser ?? vi.fn().mockResolvedValue(undefined),
+    },
+  } as unknown as SemiontClient;
+}
+
+describe('createAdminUsersStateUnit', () => {
+  it('fetches users and stats on creation', async () => {
+    const listUsers = vi.fn().mockResolvedValue({ users: [{ id: 'u1' }] });
+    const getUserStats = vi.fn().mockResolvedValue({ stats: { total: 1 } });
+    const stateUnit = createAdminUsersStateUnit(mockClient({ listUsers, getUserStats }), mockBrowse());
+
+    const users = await firstValueFrom(stateUnit.users$.pipe(filter((u) => u.length > 0)));
+    expect(users).toEqual([{ id: 'u1' }]);
+
+    const stats = await firstValueFrom(stateUnit.stats$.pipe(filter((s) => s !== null)));
+    expect(stats).toEqual({ total: 1 });
+
+    stateUnit.dispose();
+  });
+
+  it('starts with loading true, resolves to false', async () => {
+    const stateUnit = createAdminUsersStateUnit(mockClient(), mockBrowse());
+
+    await firstValueFrom(stateUnit.usersLoading$.pipe(filter((l) => !l)));
+    await firstValueFrom(stateUnit.statsLoading$.pipe(filter((l) => !l)));
+
+    stateUnit.dispose();
+  });
+
+  it('sets loading false on fetch error', async () => {
+    const listUsers = vi.fn().mockRejectedValue(new Error('fail'));
+    const getUserStats = vi.fn().mockRejectedValue(new Error('fail'));
+    const stateUnit = createAdminUsersStateUnit(mockClient({ listUsers, getUserStats }), mockBrowse());
+
+    await firstValueFrom(stateUnit.usersLoading$.pipe(filter((l) => !l)));
+    await firstValueFrom(stateUnit.statsLoading$.pipe(filter((l) => !l)));
+
+    stateUnit.dispose();
+  });
+
+  it('updateUser calls client and refetches', async () => {
+    const listUsers = vi.fn().mockResolvedValue({ users: [] });
+    const getUserStats = vi.fn().mockResolvedValue({ stats: null });
+    const updateUser = vi.fn().mockResolvedValue(undefined);
+    const stateUnit = createAdminUsersStateUnit(mockClient({ listUsers, getUserStats, updateUser }), mockBrowse());
+
+    await firstValueFrom(stateUnit.usersLoading$.pipe(filter((l) => !l)));
+    listUsers.mockClear();
+    getUserStats.mockClear();
+
+    await stateUnit.updateUser('u1', { isAdmin: true });
+
+    expect(updateUser).toHaveBeenCalledOnce();
+    expect(listUsers).toHaveBeenCalledOnce();
+    expect(getUserStats).toHaveBeenCalledOnce();
+
+    stateUnit.dispose();
+  });
+
+  it('disposes browse on dispose', () => {
+    const browse = mockBrowse();
+    const stateUnit = createAdminUsersStateUnit(mockClient(), browse);
+    stateUnit.dispose();
+    expect(browse.dispose).toHaveBeenCalled();
+  });
+});

package/src/features/admin-users/state/admin-users-state-unit.ts

@@ -0,0 +1,73 @@
+import { BehaviorSubject, type Observable } from 'rxjs';
+import { userDID } from '@semiont/core';
+import { createDisposer } from '@semiont/sdk';
+import type { StateUnit } from '@semiont/sdk';
+import type { ShellStateUnit } from '../../../state/shell-state-unit';
+import type { SemiontClient } from '@semiont/sdk';
+
+export interface AdminUsersStateUnit extends StateUnit {
+  browse: ShellStateUnit;
+  users$: Observable<unknown[]>;
+  stats$: Observable<unknown | null>;
+  usersLoading$: Observable<boolean>;
+  statsLoading$: Observable<boolean>;
+  updateUser(id: string, data: { isAdmin?: boolean; isActive?: boolean }): Promise<void>;
+}
+
+export function createAdminUsersStateUnit(
+  client: SemiontClient,
+  browse: ShellStateUnit,
+): AdminUsersStateUnit {
+  const disposer = createDisposer();
+  disposer.add(browse);
+
+  const users$ = new BehaviorSubject<unknown[]>([]);
+  const stats$ = new BehaviorSubject<unknown | null>(null);
+  const usersLoading$ = new BehaviorSubject<boolean>(true);
+  const statsLoading$ = new BehaviorSubject<boolean>(true);
+
+  const fetchUsers = () => {
+    usersLoading$.next(true);
+    client.admin!.users()
+      .then((data) => {
+        users$.next((data as { users?: unknown[] }).users ?? []);
+        usersLoading$.next(false);
+      })
+      .catch(() => usersLoading$.next(false));
+  };
+
+  const fetchStats = () => {
+    statsLoading$.next(true);
+    client.admin!.userStats()
+      .then((data) => {
+        stats$.next((data as { stats?: unknown }).stats ?? null);
+        statsLoading$.next(false);
+      })
+      .catch(() => statsLoading$.next(false));
+  };
+
+  fetchUsers();
+  fetchStats();
+
+  const updateUser = async (id: string, data: { isAdmin?: boolean; isActive?: boolean }): Promise<void> => {
+    await client.admin!.updateUser(userDID(id), data);
+    fetchUsers();
+    fetchStats();
+  };
+
+  return {
+    browse,
+    users$: users$.asObservable(),
+    stats$: stats$.asObservable(),
+    usersLoading$: usersLoading$.asObservable(),
+    statsLoading$: statsLoading$.asObservable(),
+    updateUser,
+    dispose: () => {
+      users$.complete();
+      stats$.complete();
+      usersLoading$.complete();
+      statsLoading$.complete();
+      disposer.dispose();
+    },
+  };
+}

package/src/features/auth-welcome/state/__tests__/welcome-state-unit.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect, vi } from 'vitest';
+import { firstValueFrom } from 'rxjs';
+import { filter } from 'rxjs/operators';
+import type { SemiontClient } from '@semiont/sdk';
+import { createWelcomeStateUnit } from '../welcome-state-unit';
+
+function mockClient(overrides: {
+  getMe?: ReturnType<typeof vi.fn>;
+  acceptTerms?: ReturnType<typeof vi.fn>;
+} = {}): SemiontClient {
+  return {
+    auth: {
+      me: overrides.getMe ?? vi.fn().mockResolvedValue({ termsAcceptedAt: undefined }),
+      acceptTerms: overrides.acceptTerms ?? vi.fn().mockResolvedValue(undefined),
+    },
+  } as unknown as SemiontClient;
+}
+
+describe('createWelcomeStateUnit', () => {
+  it('fetches user data on creation', async () => {
+    const getMe = vi.fn().mockResolvedValue({ termsAcceptedAt: '2026-01-01' });
+    const stateUnit = createWelcomeStateUnit(mockClient({ getMe }));
+
+    const data = await firstValueFrom(stateUnit.userData$.pipe(filter((d) => d !== null)));
+    expect(data).toEqual({ termsAcceptedAt: '2026-01-01' });
+
+    stateUnit.dispose();
+  });
+
+  it('initializes with null userData and not processing', async () => {
+    const getMe = vi.fn().mockReturnValue(new Promise(() => {}));
+    const stateUnit = createWelcomeStateUnit(mockClient({ getMe }));
+
+    const data = await firstValueFrom(stateUnit.userData$);
+    const processing = await firstValueFrom(stateUnit.isProcessing$);
+    expect(data).toBeNull();
+    expect(processing).toBe(false);
+
+    stateUnit.dispose();
+  });
+
+  it('acceptTerms sets isProcessing and updates userData', async () => {
+    const acceptTerms = vi.fn().mockResolvedValue(undefined);
+    const stateUnit = createWelcomeStateUnit(mockClient({ acceptTerms }));
+
+    await firstValueFrom(stateUnit.userData$.pipe(filter((d) => d !== null)));
+
+    await stateUnit.acceptTerms();
+
+    expect(acceptTerms).toHaveBeenCalledOnce();
+
+    const data = await firstValueFrom(stateUnit.userData$);
+    expect(data?.termsAcceptedAt).toBeDefined();
+
+    const processing = await firstValueFrom(stateUnit.isProcessing$);
+    expect(processing).toBe(false);
+
+    stateUnit.dispose();
+  });
+
+  it('acceptTerms resets isProcessing on error', async () => {
+    const acceptTerms = vi.fn().mockRejectedValue(new Error('fail'));
+    const stateUnit = createWelcomeStateUnit(mockClient({ acceptTerms }));
+
+    await firstValueFrom(stateUnit.userData$.pipe(filter((d) => d !== null)));
+
+    await expect(stateUnit.acceptTerms()).rejects.toThrow('fail');
+
+    const processing = await firstValueFrom(stateUnit.isProcessing$);
+    expect(processing).toBe(false);
+
+    stateUnit.dispose();
+  });
+
+  it('handles getMe failure gracefully', async () => {
+    const getMe = vi.fn().mockRejectedValue(new Error('unauthorized'));
+    const stateUnit = createWelcomeStateUnit(mockClient({ getMe }));
+
+    await vi.waitFor(() => expect(getMe).toHaveBeenCalled());
+
+    const data = await firstValueFrom(stateUnit.userData$);
+    expect(data).toBeNull();
+
+    stateUnit.dispose();
+  });
+});

package/src/features/auth-welcome/state/welcome-state-unit.ts

@@ -0,0 +1,44 @@
+import { BehaviorSubject, type Observable } from 'rxjs';
+import { createDisposer } from '@semiont/sdk';
+import type { StateUnit } from '@semiont/sdk';
+import type { SemiontClient } from '@semiont/sdk';
+
+export interface WelcomeStateUnit extends StateUnit {
+  userData$: Observable<{ termsAcceptedAt?: string } | null>;
+  isProcessing$: Observable<boolean>;
+  acceptTerms(): Promise<void>;
+}
+
+export function createWelcomeStateUnit(
+  client: SemiontClient,
+): WelcomeStateUnit {
+  const disposer = createDisposer();
+
+  const userData$ = new BehaviorSubject<{ termsAcceptedAt?: string } | null>(null);
+  const isProcessing$ = new BehaviorSubject<boolean>(false);
+
+  client.auth!.me()
+    .then((data) => userData$.next(data as { termsAcceptedAt?: string }))
+    .catch(() => {});
+
+  const acceptTerms = async (): Promise<void> => {
+    isProcessing$.next(true);
+    try {
+      await client.auth!.acceptTerms();
+      userData$.next({ ...userData$.getValue(), termsAcceptedAt: new Date().toISOString() });
+    } finally {
+      isProcessing$.next(false);
+    }
+  };
+
+  return {
+    userData$: userData$.asObservable(),
+    isProcessing$: isProcessing$.asObservable(),
+    acceptTerms,
+    dispose: () => {
+      userData$.complete();
+      isProcessing$.complete();
+      disposer.dispose();
+    },
+  };
+}

package/src/features/moderate-entity-tags/components/EntityTagsPage.tsx

@@ -11,7 +11,7 @@ import {
   PlusIcon,
   ExclamationCircleIcon
 } from '@heroicons/react/24/outline';
-import { COMMON_PANELS, type ToolbarPanelType } from '@semiont/sdk';
+import { COMMON_PANELS, type ToolbarPanelType } from '../../../state/shell-state-unit';
 export interface EntityTagsPageProps {
   // Data props
   entityTypes: string[];

package/src/features/moderate-entity-tags/state/__tests__/entity-tags-state-unit.test.ts

@@ -0,0 +1,102 @@
+import { describe, it, expect, vi } from 'vitest';
+import { BehaviorSubject, firstValueFrom } from 'rxjs';
+import { filter } from 'rxjs/operators';
+import type { SemiontClient } from '@semiont/sdk';
+import type { ShellStateUnit } from '../../../../state/shell-state-unit';
+import { createEntityTagsStateUnit } from '../entity-tags-state-unit';
+
+function mockBrowse(): ShellStateUnit {
+  return { dispose: vi.fn() } as unknown as ShellStateUnit;
+}
+
+function mockClient(overrides: {
+  entityTypes$?: BehaviorSubject<string[] | undefined>;
+  addEntityType?: ReturnType<typeof vi.fn>;
+} = {}): SemiontClient {
+  const entityTypes$ = overrides.entityTypes$ ?? new BehaviorSubject<string[] | undefined>(['Person', 'Place']);
+  return {
+    browse: {
+      entityTypes: () => entityTypes$.asObservable(),
+    },
+    frame: {
+      addEntityType: overrides.addEntityType ?? vi.fn().mockResolvedValue(undefined),
+    },
+  } as unknown as SemiontClient;
+}
+
+describe('createEntityTagsStateUnit', () => {
+  it('exposes entity types from browse namespace', async () => {
+    const stateUnit = createEntityTagsStateUnit(mockClient(), mockBrowse());
+
+    const types = await firstValueFrom(stateUnit.entityTypes$);
+    expect(types).toEqual(['Person', 'Place']);
+
+    stateUnit.dispose();
+  });
+
+  it('reports loading when entity types are undefined', async () => {
+    const entityTypes$ = new BehaviorSubject<string[] | undefined>(undefined);
+    const stateUnit = createEntityTagsStateUnit(mockClient({ entityTypes$ }), mockBrowse());
+
+    const loading = await firstValueFrom(stateUnit.isLoading$);
+    expect(loading).toBe(true);
+
+    entityTypes$.next(['Tag']);
+    const loaded = await firstValueFrom(stateUnit.isLoading$.pipe(filter((l) => !l)));
+    expect(loaded).toBe(false);
+
+    stateUnit.dispose();
+  });
+
+  it('setNewTag updates newTag$', async () => {
+    const stateUnit = createEntityTagsStateUnit(mockClient(), mockBrowse());
+
+    stateUnit.setNewTag('Organization');
+    const tag = await firstValueFrom(stateUnit.newTag$);
+    expect(tag).toBe('Organization');
+
+    stateUnit.dispose();
+  });
+
+  it('addTag calls client and clears newTag$', async () => {
+    const addEntityType = vi.fn().mockResolvedValue(undefined);
+    const stateUnit = createEntityTagsStateUnit(mockClient({ addEntityType }), mockBrowse());
+
+    stateUnit.setNewTag('Event');
+    await stateUnit.addTag();
+
+    expect(addEntityType).toHaveBeenCalledWith('Event');
+    const tag = await firstValueFrom(stateUnit.newTag$);
+    expect(tag).toBe('');
+
+    stateUnit.dispose();
+  });
+
+  it('addTag ignores empty/whitespace input', async () => {
+    const addEntityType = vi.fn();
+    const stateUnit = createEntityTagsStateUnit(mockClient({ addEntityType }), mockBrowse());
+
+    stateUnit.setNewTag('   ');
+    await stateUnit.addTag();
+
+    expect(addEntityType).not.toHaveBeenCalled();
+
+    stateUnit.dispose();
+  });
+
+  it('addTag sets error on failure', async () => {
+    const addEntityType = vi.fn().mockRejectedValue(new Error('duplicate'));
+    const stateUnit = createEntityTagsStateUnit(mockClient({ addEntityType }), mockBrowse());
+
+    stateUnit.setNewTag('Person');
+    await stateUnit.addTag();
+
+    const error = await firstValueFrom(stateUnit.error$);
+    expect(error).toBe('duplicate');
+
+    const adding = await firstValueFrom(stateUnit.isAdding$);
+    expect(adding).toBe(false);
+
+    stateUnit.dispose();
+  });
+});

package/src/features/moderate-entity-tags/state/entity-tags-state-unit.ts

@@ -0,0 +1,64 @@
+import { BehaviorSubject, type Observable, map } from 'rxjs';
+import { createDisposer } from '@semiont/sdk';
+import type { StateUnit } from '@semiont/sdk';
+import type { ShellStateUnit } from '../../../state/shell-state-unit';
+import type { SemiontClient } from '@semiont/sdk';
+
+export interface EntityTagsStateUnit extends StateUnit {
+  browse: ShellStateUnit;
+  entityTypes$: Observable<string[]>;
+  isLoading$: Observable<boolean>;
+  newTag$: Observable<string>;
+  error$: Observable<string>;
+  isAdding$: Observable<boolean>;
+  setNewTag(value: string): void;
+  addTag(): Promise<void>;
+}
+
+export function createEntityTagsStateUnit(
+  client: SemiontClient,
+  browse: ShellStateUnit,
+): EntityTagsStateUnit {
+  const disposer = createDisposer();
+  disposer.add(browse);
+
+  const newTag$ = new BehaviorSubject<string>('');
+  const error$ = new BehaviorSubject<string>('');
+  const isAdding$ = new BehaviorSubject<boolean>(false);
+
+  const raw$ = client.browse.entityTypes();
+  const entityTypes$: Observable<string[]> = raw$.pipe(map((e) => e ?? []));
+  const isLoading$: Observable<boolean> = raw$.pipe(map((e) => e === undefined));
+
+  const addTag = async (): Promise<void> => {
+    const tag = newTag$.getValue().trim();
+    if (!tag) return;
+    error$.next('');
+    isAdding$.next(true);
+    try {
+      await client.frame.addEntityType(tag);
+      newTag$.next('');
+    } catch (err) {
+      error$.next(err instanceof Error ? err.message : 'Failed to add entity type');
+    } finally {
+      isAdding$.next(false);
+    }
+  };
+
+  return {
+    browse,
+    entityTypes$,
+    isLoading$,
+    newTag$: newTag$.asObservable(),
+    error$: error$.asObservable(),
+    isAdding$: isAdding$.asObservable(),
+    setNewTag: (v) => newTag$.next(v),
+    addTag,
+    dispose: () => {
+      newTag$.complete();
+      error$.complete();
+      isAdding$.complete();
+      disposer.dispose();
+    },
+  };
+}

package/src/features/moderate-recent/components/RecentDocumentsPage.tsx

@@ -7,7 +7,7 @@
 
 import React from 'react';
 import { ClockIcon } from '@heroicons/react/24/outline';
-import { COMMON_PANELS, type ToolbarPanelType } from '@semiont/sdk';
+import { COMMON_PANELS, type ToolbarPanelType } from '../../../state/shell-state-unit';
 export interface RecentDocumentsPageProps {
   // Data props
   hasDocuments: boolean;

package/src/features/moderate-tag-schemas/components/TagSchemasPage.tsx

@@ -11,7 +11,7 @@ import {
   ScaleIcon,
   LightBulbIcon
 } from '@heroicons/react/24/outline';
-import { COMMON_PANELS, type ToolbarPanelType } from '@semiont/sdk';
+import { COMMON_PANELS, type ToolbarPanelType } from '../../../state/shell-state-unit';
 import type { TagSchema } from '@semiont/react-ui';
 
 export interface TagSchemasPageProps {

package/src/features/moderation-linked-data/components/LinkedDataPage.tsx

@@ -6,7 +6,7 @@
  */
 
 import React from 'react';
-import { COMMON_PANELS, type ToolbarPanelType } from '@semiont/sdk';
+import { COMMON_PANELS, type ToolbarPanelType } from '../../../state/shell-state-unit';
 import { ExportCard, type ExportCardTranslations } from '../../admin-exchange/components/ExportCard';
 import { ImportCard, type ImportCardProps, type ImportCardTranslations } from '../../admin-exchange/components/ImportCard';
 import { ImportProgress, type ImportProgressTranslations } from '../../admin-exchange/components/ImportProgress';