@modern-js/plugin 1.0.0 → 1.1.2

package/tests/context.test.ts

@@ -1,114 +0,0 @@
-import {
-  createContext,
-  createContainer,
-  useContainer,
-  fromContainer,
-  runHooks,
-  isContext,
-  assertContext,
-  isContainer,
-  assertContainer,
-} from '@/context';
-
-describe('context', () => {
-  it('different values in Containers with same Context', () => {
-    const Context0 = createContext({ count: 0 });
-
-    const Context1 = createContext({ text: 'test' });
-
-    const container = createContainer();
-
-    expect(container.read(Context0)).toEqual({ count: 0 });
-
-    expect(container.read(Context1)).toEqual({ text: 'test' });
-
-    container.write(Context0, { count: 1 });
-
-    expect(container.read(Context0)).toEqual({ count: 1 });
-
-    container.write(Context1, { text: 'update test' });
-
-    expect(container.read(Context1)).toEqual({ text: 'update test' });
-  });
-
-  it('inject new Context to Container', () => {
-    const Context0 = createContext({ count: 0 });
-
-    const Context1 = createContext({ text: 'test' });
-
-    const container = createContainer({
-      count: Context0.create({ count: 1 }),
-      text: Context1.create({ text: 'new text' }),
-    });
-
-    expect(container.read(Context0)).toEqual({ count: 1 });
-
-    expect(container.read(Context1)).toEqual({ text: 'new text' });
-  });
-
-  it('run hook with container', () => {
-    const Context0 = createContext({ count: 0 });
-
-    const Context1 = createContext({ text: 'test' });
-
-    const container = createContainer({
-      count: Context0.create({ count: 1 }),
-      text: Context1.create({ text: 'new text' }),
-    });
-
-    runHooks(() => {
-      const ctn = useContainer();
-
-      expect(container === ctn).toBeTruthy();
-
-      expect(ctn.read(Context0)).toEqual({ count: 1 });
-
-      expect(ctn.read(Context1)).toEqual({ text: 'new text' });
-    }, fromContainer(container));
-  });
-
-  it('assert Context', () => {
-    const context = createContext<number | null>(null);
-
-    const container = createContainer();
-
-    runHooks(() => {
-      expect(() => context.assert()).toThrowError();
-
-      context.set(0);
-
-      expect(context.assert()).toBe(0);
-    }, fromContainer(container));
-  });
-
-  it('isContext', () => {
-    const context = createContext(0);
-
-    expect(isContext(context)).toBeTruthy();
-    expect(isContext({})).toBeFalsy();
-  });
-
-  it('assertContext', () => {
-    const context = createContext(0);
-
-    assertContext(context);
-
-    expect(() => assertContext({})).toThrowError();
-  });
-
-  it('isContainer', () => {
-    const container = createContainer();
-
-    expect(isContainer(container)).toBeTruthy();
-    expect(isContainer({})).toBeFalsy();
-    expect(isContainer(null)).toBeFalsy();
-  });
-
-  it('assertContainer', () => {
-    const container = createContainer();
-
-    assertContainer(container);
-
-    expect(() => assertContainer({})).toThrowError();
-  });
-});

package/tests/counter.test.ts

@@ -1,32 +0,0 @@
-import { createCounter, createAsyncCounter } from '@/counter';
-
-describe('counter', () => {
-  describe('sync', () => {
-    it('base usage', () => {
-      const counter = createCounter<number, number>((index, input, next) => {
-        if (index >= 10) {
-          return input;
-        }
-        return next(input * 2);
-      });
-
-      expect(counter.start(1)).toBe(2 ** 10);
-    });
-  });
-
-  describe('async', () => {
-    it('base usage', async () => {
-      const counter = createAsyncCounter<number, number>(
-        // eslint-disable-next-line @typescript-eslint/require-await
-        async (index, input, next) => {
-          if (index >= 10) {
-            return input;
-          }
-          return next(input * 2);
-        },
-      );
-
-      expect(await counter.start(1)).toBe(2 ** 10);
-    });
-  });
-});

package/tests/hook.test.ts

@@ -1,113 +0,0 @@
-import { sleep } from './helpers';
-import { enable, disable } from '@/asyncHooksImpl';
-import { createHooks } from '@/hook';
-
-describe('hook', () => {
-  it('should support sync runner', () => {
-    type Hooks = {
-      useCount: () => number;
-    };
-
-    const {
-      run,
-      hooks: { useCount },
-    } = createHooks<Hooks>({
-      useCount: () => {
-        throw new Error(`useCount can't not be called after initilizing`);
-      },
-    });
-
-    let count = 0;
-    const implementations: Hooks = { useCount: () => count++ };
-    run(() => {
-      expect(useCount()).toBe(0);
-      expect(useCount()).toBe(1);
-      expect(useCount()).toBe(2);
-      expect(useCount()).toBe(3);
-    }, implementations);
-  });
-
-  it('should support async runner', async () => {
-    type Hooks = {
-      useCount: () => number;
-    };
-
-    const {
-      run,
-      hooks: { useCount },
-    } = createHooks<Hooks>({
-      useCount: () => {
-        throw new Error(`useCount can't not be called after initilizing`);
-      },
-    });
-
-    let count = 0;
-    const implementations: Hooks = { useCount: () => count++ };
-
-    enable();
-
-    await run(async () => {
-      expect(useCount()).toBe(0);
-      await sleep(0);
-      expect(useCount()).toBe(1);
-      await sleep(0);
-      expect(useCount()).toBe(2);
-      await sleep(0);
-      expect(useCount()).toBe(3);
-    }, implementations);
-
-    disable();
-  });
-
-  it('should use default hook with passing new one', () => {
-    type Hooks = {
-      useCount: () => number;
-    };
-
-    const {
-      run,
-      hooks: { useCount },
-    } = createHooks<Hooks>({
-      useCount: () => {
-        throw new Error(`useCount can't not be called after initilizing`);
-      },
-    });
-
-    enable();
-
-    run(() => {
-      expect(useCount).toThrowError(
-        new Error(`useCount can't not be called after initilizing`),
-      );
-    });
-
-    disable();
-  });
-
-  it('should fallback to default hook', () => {
-    type Hooks = {
-      useCount: () => number;
-    };
-
-    const {
-      run,
-      hooks: { useCount },
-    } = createHooks<Hooks>({
-      useCount: () => {
-        throw new Error(`useCount can't not be called after initilizing`);
-      },
-    });
-
-    const implementations: Hooks = { useCount: '' } as any;
-
-    enable();
-
-    run(() => {
-      expect(useCount).toThrowError(
-        new Error(`useCount can't not be called after initilizing`),
-      );
-    }, implementations);
-
-    disable();
-  });
-});