@modern-js/plugin 1.0.1 → 1.2.0

package/src/pipeline/sync.ts

@@ -1,152 +0,0 @@
-/**
- * Copyright Lucifier129 and other contributors.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file at
- * https://github.com/farrow-js/farrow/blob/master/LICENSE
- *
- */
-
-import {
-  createContainer,
-  ContextStorage,
-  Container,
-  fromContainer,
-  runHooks,
-  useContainer,
-  Hooks,
-} from '../context';
-
-import { Next, createCounter } from '../counter';
-
-export type Middleware<I = unknown, O = unknown> = (
-  input: I,
-  next: Next<I, O>,
-) => O;
-
-export type Middlewares<I = unknown, O = unknown> = Middleware<I, O>[];
-
-const PIPELINE_SYMBOL = Symbol('PIPELINE_SYMBOL');
-export const isPipeline = (input: any): input is Pipeline =>
-  Boolean(input?.[PIPELINE_SYMBOL]);
-
-export type PipelineOptions = {
-  contexts?: ContextStorage;
-};
-
-export type RunPipelineOptions<I = unknown, O = unknown> = {
-  container?: Container;
-  onLast?: (input: I) => O;
-};
-
-export type MiddlewareInput<I = unknown, O = unknown> =
-  | Middleware<I, O>
-  | { middleware: Middleware<I, O> };
-
-export type MiddlewareType<T extends MiddlewareInput> =
-  T extends MiddlewareInput<infer I, infer O> ? Middleware<I, O> : never;
-
-export const getMiddleware = <I, O>(input: MiddlewareInput<I, O>) => {
-  if (typeof input === 'function') {
-    return input;
-  } else if (input && typeof input.middleware === 'function') {
-    return input.middleware;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-base-to-string,@typescript-eslint/restrict-template-expressions
-  throw new Error(`${input} is not a Middleware or { middleware: Middleware }`);
-};
-
-export type Pipeline<I = unknown, O = unknown> = {
-  [PIPELINE_SYMBOL]: true;
-  use: (...inputs: MiddlewareInput<I, O>[]) => Pipeline<I, O>;
-  run: (input: I, options?: RunPipelineOptions<I, O>) => O;
-  middleware: Middleware<I, O>;
-};
-
-export const createPipeline = <I, O>(options?: PipelineOptions) => {
-  const config = { ...options };
-
-  const middlewares: Middlewares<I, O> = [];
-
-  const use: Pipeline<I, O>['use'] = (...inputs) => {
-    middlewares.push(...inputs.map(getMiddleware));
-    return pipeline;
-  };
-
-  const createCurrentCounter = (hooks: Hooks, onLast?: (input: I) => O) =>
-    createCounter<I, O>((index, input, next) => {
-      if (index >= middlewares.length) {
-        if (onLast) {
-          return onLast(input);
-        }
-        throw new Error(
-          `Expect returning a value, but all middlewares just calling next()`,
-        );
-      }
-
-      const middleware = middlewares[index];
-      const result = runHooks(() => middleware(input, next), hooks);
-
-      return result;
-    });
-
-  const currentContainer = createContainer(config.contexts);
-  const currentHooks = fromContainer(currentContainer);
-  const currentCounter = createCurrentCounter(currentHooks);
-
-  // eslint-disable-next-line @typescript-eslint/no-shadow
-  const run: Pipeline<I, O>['run'] = (input, options) => {
-    const container = options?.container ?? currentContainer;
-    const hooks =
-      container === currentContainer ? currentHooks : fromContainer(container);
-    let counter =
-      container === currentContainer
-        ? currentCounter
-        : createCurrentCounter(hooks);
-
-    if (options?.onLast) {
-      counter = createCurrentCounter(hooks, options.onLast);
-    }
-
-    const result = counter.start(input);
-
-    return result;
-  };
-
-  const middleware: Pipeline<I, O>['middleware'] = (input, next) => {
-    // eslint-disable-next-line react-hooks/rules-of-hooks
-    const container = useContainer();
-    return run(input, {
-      container,
-      onLast: next,
-    });
-  };
-
-  const pipeline: Pipeline<I, O> = {
-    [PIPELINE_SYMBOL]: true,
-    use,
-    run,
-    middleware,
-  };
-
-  return pipeline;
-};
-
-export type PipelineInput<T extends Pipeline> = T extends Pipeline<infer I>
-  ? I
-  : never;
-export type PipelineOutput<T extends Pipeline> = T extends Pipeline<
-  any,
-  infer O
->
-  ? O
-  : never;
-
-export const usePipeline = <I, O>(pipeline: Pipeline<I, O>) => {
-  const container = useContainer();
-
-  const runPipeline = (input: I, options?: RunPipelineOptions<I, O>): O =>
-    pipeline.run(input, { ...options, container });
-
-  return runPipeline;
-};

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,31 +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>(
-        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();
-  });
-});