@aiao/rxdb-angular 0.0.7 → 0.0.9

package/src/use-action.spec.ts

@@ -1,88 +0,0 @@
-import { provideZonelessChangeDetection } from '@angular/core';
-import { TestBed } from '@angular/core/testing';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { useAction } from './use-action';
-
-describe('useAction', () => {
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      providers: [provideZonelessChangeDetection()]
-    });
-  });
-  it('should create an action with isPending signal', () => {
-    TestBed.runInInjectionContext(() => {
-      const mockFn = vi.fn(async () => 'result');
-      const action = useAction(mockFn);
-
-      expect(action.isPending).toBeDefined();
-      expect(action.execute).toBeDefined();
-      expect(action.isPending()).toBe(false);
-    });
-  });
-
-  it('should set isPending to true during execution', async () => {
-    await TestBed.runInInjectionContext(async () => {
-      let resolvePromise: (value: string) => void;
-      const mockFn = vi.fn(
-        () =>
-          new Promise<string>(resolve => {
-            resolvePromise = resolve;
-          })
-      );
-      const action = useAction(mockFn);
-
-      const executePromise = action.execute();
-      expect(action.isPending()).toBe(true);
-
-      resolvePromise!('result');
-      await executePromise;
-      expect(action.isPending()).toBe(false);
-    });
-  });
-
-  it('should execute the promise function with options', async () => {
-    await TestBed.runInInjectionContext(async () => {
-      const mockFn = vi.fn(async (options?: { id: number }) => `result-${options?.id}`);
-      const action = useAction(mockFn);
-
-      const result = await action.execute({ id: 123 });
-
-      expect(mockFn).toHaveBeenCalledWith({ id: 123 });
-      expect(result).toBe('result-123');
-    });
-  });
-
-  it('should reset isPending to false after success', async () => {
-    await TestBed.runInInjectionContext(async () => {
-      const mockFn = vi.fn(async () => 'success');
-      const action = useAction(mockFn);
-
-      await action.execute();
-
-      expect(action.isPending()).toBe(false);
-    });
-  });
-
-  it('should reset isPending to false after error', async () => {
-    await TestBed.runInInjectionContext(async () => {
-      const mockFn = vi.fn(async () => {
-        throw new Error('test error');
-      });
-      const action = useAction(mockFn);
-
-      await expect(action.execute()).rejects.toThrow('test error');
-      expect(action.isPending()).toBe(false);
-    });
-  });
-
-  it('should return the result from promise function', async () => {
-    await TestBed.runInInjectionContext(async () => {
-      const mockFn = vi.fn(async () => ({ data: 'test' }));
-      const action = useAction(mockFn);
-
-      const result = await action.execute();
-
-      expect(result).toEqual({ data: 'test' });
-    });
-  });
-});

package/src/use-action.ts

@@ -1,20 +0,0 @@
-import { signal } from '@angular/core';
-
-const action = <Options = any, RT = any>(promiseFn: (options?: Options) => Promise<RT>) => {
-  const isPending = signal<boolean>(false);
-  return {
-    isPending,
-    execute: async (options?: Options) => {
-      isPending.set(true);
-      try {
-        const d = await promiseFn(options);
-        return d;
-      } finally {
-        isPending.set(false);
-      }
-    }
-  };
-};
-
-export const useAction = <Options = any, RT = any>(promiseFn: (options?: Options) => Promise<RT>) =>
-  action<Options, RT>(promiseFn);

package/src/use-state.spec.ts

@@ -1,105 +0,0 @@
-import { provideZonelessChangeDetection } from '@angular/core';
-import { TestBed } from '@angular/core/testing';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { useState } from './use-state';
-
-describe('useState', () => {
-  const mockLocalStorage = (() => {
-    let store: Record<string, string> = {};
-    return {
-      getItem: vi.fn((key: string) => store[key] || null),
-      setItem: vi.fn((key: string, value: string) => {
-        store[key] = value;
-      }),
-      clear: () => {
-        store = {};
-      }
-    };
-  })();
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      providers: [provideZonelessChangeDetection()]
-    });
-    Object.defineProperty(globalThis, 'localStorage', {
-      value: mockLocalStorage,
-      writable: true
-    });
-    mockLocalStorage.clear();
-    mockLocalStorage.getItem.mockClear();
-    mockLocalStorage.setItem.mockClear();
-  });
-
-  afterEach(() => {
-    TestBed.resetTestingModule();
-  });
-
-  it('should create a signal with initial value', () => {
-    TestBed.runInInjectionContext(() => {
-      const state = useState('test-namespace')('test-key');
-      const testSignal = state.signal(42);
-
-      expect(testSignal()).toBe(42);
-    });
-  });
-
-  it('should load value from localStorage if exists', () => {
-    mockLocalStorage.setItem('test-namespace:test-key', JSON.stringify(100));
-
-    TestBed.runInInjectionContext(() => {
-      const state = useState('test-namespace')('test-key');
-      const testSignal = state.signal(42);
-
-      expect(mockLocalStorage.getItem).toHaveBeenCalledWith('test-namespace:test-key');
-      expect(testSignal()).toBe(100);
-    });
-  });
-
-  it('should save value to localStorage on change', async () => {
-    TestBed.runInInjectionContext(() => {
-      const state = useState('test-namespace')('test-key');
-      const testSignal = state.signal(42);
-
-      testSignal.set(100);
-
-      // Wait for effect to run
-      TestBed.flushEffects();
-
-      expect(mockLocalStorage.setItem).toHaveBeenCalledWith('test-namespace:test-key', JSON.stringify(100));
-    });
-  });
-
-  it('should use namespace and name to construct storage key', () => {
-    TestBed.runInInjectionContext(() => {
-      const state = useState('my-app')('user-settings');
-      state.signal({ theme: 'dark' });
-
-      TestBed.flushEffects();
-
-      expect(mockLocalStorage.setItem).toHaveBeenCalledWith('my-app:user-settings', JSON.stringify({ theme: 'dark' }));
-    });
-  });
-
-  it('should handle objects and arrays', async () => {
-    TestBed.runInInjectionContext(() => {
-      const state = useState('test-namespace')('test-array');
-      const testSignal = state.signal([1, 2, 3]);
-
-      testSignal.set([4, 5, 6]);
-
-      TestBed.flushEffects();
-
-      expect(mockLocalStorage.setItem).toHaveBeenCalledWith('test-namespace:test-array', JSON.stringify([4, 5, 6]));
-    });
-  });
-
-  it('should respect CreateSignalOptions', () => {
-    TestBed.runInInjectionContext(() => {
-      const equalFn = vi.fn((a: number, b: number) => a === b);
-      const state = useState('test-namespace')('test-with-options');
-      const testSignal = state.signal(42, { equal: equalFn });
-
-      expect(testSignal()).toBe(42);
-    });
-  });
-});

package/src/use-state.ts

@@ -1,28 +0,0 @@
-import { IS_BROWSER } from '@aiao/utils';
-import { CreateSignalOptions, effect, signal as ngSignal, WritableSignal } from '@angular/core';
-
-function state(namespace: string) {
-  return (name: string) => {
-    const signal = <T>(initialValue: T, options?: CreateSignalOptions<T>): WritableSignal<T> => {
-      if (IS_BROWSER) {
-        const value = localStorage.getItem(`${namespace}:${name}`);
-        if (value) {
-          initialValue = JSON.parse(value);
-        }
-      }
-      const a = ngSignal<T>(initialValue, options);
-      effect(() => {
-        if (IS_BROWSER) {
-          localStorage.setItem(`${namespace}:${name}`, JSON.stringify(a()));
-        }
-      });
-      return a;
-    };
-
-    return {
-      signal
-    };
-  };
-}
-
-export const useState = (namespace: string) => state(namespace);

package/tsconfig.json

@@ -1,33 +0,0 @@
-{
-  "angularCompilerOptions": {
-    "enableI18nLegacyMessageIdFormat": false,
-    "strictInjectionParameters": true,
-    "strictInputAccessModifiers": true,
-    "typeCheckHostBindings": true,
-    "strictTemplates": true
-  },
-  "compilerOptions": {
-    "skipLibCheck": true,
-    "experimentalDecorators": true,
-    "importHelpers": true,
-    "target": "es2022",
-    "moduleResolution": "bundler",
-    "strict": true,
-    "noImplicitOverride": true,
-    "noPropertyAccessFromIndexSignature": true,
-    "noImplicitReturns": true,
-    "noFallthroughCasesInSwitch": true,
-    "module": "preserve"
-  },
-  "extends": "../../tsconfig.angular.json",
-  "files": [],
-  "include": [],
-  "references": [
-    {
-      "path": "./tsconfig.lib.json"
-    },
-    {
-      "path": "./tsconfig.spec.json"
-    }
-  ]
-}

package/tsconfig.lib.json

@@ -1,42 +0,0 @@
-{
-  "compilerOptions": {
-    "outDir": "../../dist/out-tsc",
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "inlineSources": true,
-    "module": "preserve",
-    "moduleResolution": "bundler",
-    "emitDeclarationOnly": false,
-    "types": []
-  },
-  "exclude": [
-    "src/**/*.spec.ts",
-    "src/test-setup.ts",
-    "jest.config.ts",
-    "src/**/*.test.ts",
-    "vite.config.ts",
-    "vite.config.mts",
-    "vitest.config.ts",
-    "vitest.config.mts",
-    "src/**/*.test.tsx",
-    "src/**/*.spec.tsx",
-    "src/**/*.test.js",
-    "src/**/*.spec.js",
-    "src/**/*.test.jsx",
-    "src/**/*.spec.jsx"
-  ],
-  "extends": "./tsconfig.json",
-  "include": ["src/**/*.ts"],
-  "references": [
-    {
-      "path": "../rxdb-plugin-graph/tsconfig.lib.json"
-    },
-    {
-      "path": "../utils/tsconfig.lib.json"
-    },
-    {
-      "path": "../rxdb/tsconfig.lib.json"
-    }
-  ]
-}

package/tsconfig.lib.prod.json

@@ -1,10 +0,0 @@
-{
-  "angularCompilerOptions": {
-    "compilationMode": "partial"
-  },
-  "compilerOptions": {
-    "declarationMap": false
-  },
-  "extends": "./tsconfig.lib.json",
-  "include": ["src/**/*.ts"]
-}

package/tsconfig.spec.json

@@ -1,23 +0,0 @@
-{
-  "compilerOptions": {
-    "outDir": "../../dist/out-tsc",
-    "types": ["node"]
-  },
-  "extends": "./tsconfig.json",
-  "include": [
-    "src/test-setup.ts",
-    "vite.config.ts",
-    "vite.config.mts",
-    "vitest.config.ts",
-    "vitest.config.mts",
-    "src/**/*.test.ts",
-    "src/**/*.spec.ts",
-    "src/**/*.test.tsx",
-    "src/**/*.spec.tsx",
-    "src/**/*.test.js",
-    "src/**/*.spec.js",
-    "src/**/*.test.jsx",
-    "src/**/*.spec.jsx",
-    "src/**/*.d.ts"
-  ]
-}

package/vite.config.mts

@@ -1,55 +0,0 @@
-/// <reference types='vitest' />
-import angular from '@analogjs/vite-plugin-angular';
-import { codecovVitePlugin } from '@codecov/vite-plugin';
-import { nxCopyAssetsPlugin } from '@nx/vite/plugins/nx-copy-assets.plugin';
-import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin';
-import * as path from 'path';
-import { fileURLToPath } from 'url';
-import { defineConfig } from 'vite';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-export default defineConfig({
-  root: __dirname,
-  cacheDir: '../../node_modules/.vite/packages/rxdb-angular',
-  plugins: [
-    angular(),
-    nxViteTsPaths(),
-    nxCopyAssetsPlugin(['*.md']),
-    // Codecov Bundle Analysis - 仅在 CI 环境中启用
-    ...(process.env['CI'] === 'true' && process.env['CODECOV_TOKEN'] ?
-      [
-        codecovVitePlugin({
-          enableBundleAnalysis: true,
-          telemetry: false,
-          bundleName: 'rxdb-angular',
-          uploadToken: process.env['CODECOV_TOKEN']
-        })
-      ]
-    : [])
-  ],
-  // Uncomment this if you are using workers.
-  // worker: {
-  //  plugins: [ nxViteTsPaths() ],
-  // },
-  test: {
-    name: 'rxdb-angular',
-    watch: false,
-    globals: true,
-    environment: 'happy-dom',
-    passWithNoTests: true,
-    testTimeout: 10000,
-    hookTimeout: 10000,
-    include: ['{src,tests}/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
-    setupFiles: ['src/test-setup.ts'],
-    reporters: ['default', 'junit'],
-    outputFile: {
-      junit: '../../coverage/packages/rxdb-angular/junit.xml'
-    },
-    coverage: {
-      enabled: true,
-      reportsDirectory: '../../coverage/packages/rxdb-angular',
-      provider: 'v8' as const
-    }
-  }
-});