@modern-js/plugin 1.0.0 → 1.1.2

package/src/context.ts

@@ -1,184 +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 { createHooks } from './hook';
-
-const ContextSymbol = Symbol('Context');
-
-export type Context<T = any> = {
-  id: symbol;
-  [ContextSymbol]: T;
-  // create a new context equipped a new value
-  create: (value: T) => Context<T>;
-  // get context ref { value } for accessing context in current container of waterfall
-  use: () => {
-    value: T;
-  };
-  // get context value
-  get: () => T;
-  // set context value
-  set: (value: T) => void;
-  // assert context value is not null or undefined and return context value
-  assert: () => Exclude<T, undefined | null>;
-};
-
-export const isContext = (input: any): input is Context =>
-  Object.prototype.hasOwnProperty.call(input, ContextSymbol);
-
-type AssertContext = (input: any) => asserts input is Context;
-
-export const assertContext: AssertContext = input => {
-  if (!isContext(input)) {
-    throw new Error(`Expected Context, but received ${input}`);
-  }
-};
-
-export const createContext = <T>(value: T) => {
-  const id = Symbol('ContextID');
-
-  // eslint-disable-next-line @typescript-eslint/no-shadow
-  const create = (value: T): Context<T> => {
-    const use = () => {
-      // eslint-disable-next-line react-hooks/rules-of-hooks
-      const container = useContainer();
-      return Object.seal({
-        get value() {
-          return container.read(Context);
-        },
-        set value(v) {
-          container.write(Context, v);
-        },
-      });
-    };
-    const get = () => {
-      // eslint-disable-next-line react-hooks/rules-of-hooks
-      const container = useContainer();
-      return container.read(Context);
-    };
-    const set = (v: T) => {
-      // eslint-disable-next-line react-hooks/rules-of-hooks
-      const container = useContainer();
-      container.write(Context, v);
-    };
-    const assert = () => {
-      // eslint-disable-next-line @typescript-eslint/no-shadow
-      const value = get();
-      if (value === null || value === undefined) {
-        throw new Error(
-          // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-          `Expected value is not null or undefined, but got: ${value}`,
-        );
-      }
-      return value as Exclude<T, null | undefined>;
-    };
-    const Context: Context<T> = {
-      id,
-      [ContextSymbol]: value,
-      create,
-      use,
-      get,
-      set,
-      assert,
-    };
-    return Context;
-  };
-
-  return create(value);
-};
-
-export type ContextStorage = {
-  [key: string]: Context;
-};
-
-export const ContainerSymbol = Symbol('Container');
-
-// eslint-disable-next-line @typescript-eslint/no-redeclare
-export type ContextSymbol = typeof ContainerSymbol;
-
-export const isContainer = (input: any): input is Container =>
-  Boolean(input?.[ContainerSymbol]);
-
-type AssertContainer = (input: any) => asserts input is Container;
-
-export const assertContainer: AssertContainer = input => {
-  if (!isContainer(input)) {
-    throw new Error(`Expected Context, but received ${input}`);
-  }
-};
-
-export type Container = {
-  [ContainerSymbol]: true;
-  read: <V>(Context: Context<V>) => V;
-  write: <V>(Context: Context<V>, value: V) => void;
-};
-
-const createContextMap = (storage: ContextStorage) => {
-  const contextMap = new Map<symbol, Context>();
-
-  Object.values(storage).forEach(context => {
-    contextMap.set(context.id, context);
-  });
-
-  return contextMap;
-};
-
-export const createContainer = (
-  ContextStorage: ContextStorage = {},
-): Container => {
-  const contextMap = createContextMap(ContextStorage);
-
-  const read: Container['read'] = context => {
-    const target = contextMap.get(context.id);
-    if (target) {
-      return target[ContextSymbol];
-    }
-    return context[ContextSymbol];
-  };
-
-  const write: Container['write'] = (context, value) => {
-    contextMap.set(context.id, context.create(value));
-  };
-
-  const container: Container = Object.freeze({
-    [ContainerSymbol]: true,
-    read,
-    write,
-  });
-
-  return container;
-};
-
-export type ValueFromContext<C extends Context> = C extends Context<infer V>
-  ? V
-  : never;
-
-export type Hooks = {
-  useContainer: () => Container;
-};
-
-const { run, hooks } = createHooks<Hooks>({
-  useContainer: () => {
-    throw new Error(
-      `Can't call useContainer out of scope, it should be placed on top of the function`,
-    );
-  },
-});
-
-export const runHooks = run;
-
-export const { useContainer } = hooks;
-
-export const fromContainer = (container: Container): Hooks => ({
-  useContainer: () => container,
-});
-
-export const runWithContainer = <F extends (...args: any) => any>(
-  f: F,
-  container: Container,
-) => runHooks(f, fromContainer(container));

package/src/counter.ts

@@ -1,78 +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
- *
- */
-
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-export type Next<I = unknown, O = void> = (input?: I) => O;
-
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-export type CounterCallback<I = unknown, O = void> = (
-  index: number,
-  input: I,
-  next: Next<I, O>,
-) => O;
-
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-export type Counter<I = unknown, O = void> = {
-  start: (input: I) => O;
-  dispatch: (index: number, input: I) => O;
-};
-
-export const createCounter = <I, O>(
-  callback: CounterCallback<I, O>,
-): Counter<I, O> => {
-  type Dispatch = Counter<I, O>['dispatch'];
-  type Start = Counter<I, O>['start'];
-
-  const dispatch: Dispatch = (index, input) => {
-    const next = (nextInput = input) => dispatch(index + 1, nextInput);
-    return callback(index, input, next);
-  };
-
-  const start: Start = input => dispatch(0, input);
-
-  return {
-    start,
-    dispatch,
-  };
-};
-
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-export type AsyncNext<I = unknown, O = void> = (input: I) => Promise<O>;
-
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-export type AsyncCounterCallback<I = unknown, O = void> = (
-  index: number,
-  input: I,
-  next: AsyncNext<I, O>,
-) => Promise<O>;
-
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-export type AsyncCounter<I = unknown, O = void> = {
-  start: (input: I) => Promise<O>;
-  dispatch: (index: number, input: I) => Promise<O>;
-};
-
-export const createAsyncCounter = <I, O>(
-  callback: AsyncCounterCallback<I, O>,
-): AsyncCounter<I, O> => {
-  type Dispatch = AsyncCounter<I, O>['dispatch'];
-  type Start = AsyncCounter<I, O>['start'];
-
-  const dispatch: Dispatch = async (index, input) => {
-    const next = (nextInput = input) => dispatch(index + 1, nextInput);
-    return callback(index, input, next);
-  };
-
-  const start: Start = input => dispatch(0, input);
-
-  return {
-    start,
-    dispatch,
-  };
-};

package/src/hook.ts

@@ -1,46 +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 { Hooks, AnyFn, asyncHooks } from './asyncHooksInterface';
-
-export const createHooks = <HS extends Hooks>(defaultHooks: HS) => {
-  let currentHooks = {} as HS;
-
-  const hooks = {} as HS;
-
-  for (const key in defaultHooks) {
-    // eslint-disable-next-line @typescript-eslint/no-loop-func
-    const f = ((...args) => {
-      // eslint-disable-next-line @typescript-eslint/no-shadow
-      const hooks =
-        currentHooks === defaultHooks
-          ? asyncHooks?.get() ?? defaultHooks
-          : currentHooks;
-      let handler = hooks[key];
-      if (typeof handler !== 'function') {
-        handler = defaultHooks[key];
-      }
-      return handler(...args);
-    }) as HS[typeof key];
-
-    hooks[key] = f;
-  }
-
-  const run = <F extends AnyFn>(f: F, implementations?: HS): ReturnType<F> => {
-    try {
-      currentHooks = implementations || defaultHooks;
-      asyncHooks?.set(currentHooks);
-      return f();
-    } finally {
-      currentHooks = defaultHooks;
-    }
-  };
-
-  return { run, hooks };
-};

package/src/pipeline/async.ts

@@ -1,155 +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,
-  Container,
-  fromContainer,
-  runHooks,
-  useContainer,
-  Hooks,
-} from '../context';
-
-import { AsyncNext, createAsyncCounter } from '../counter';
-
-import type { PipelineOptions } from './sync';
-
-export type AsyncMiddleware<I = unknown, O = unknown> = (
-  input: I,
-  next: AsyncNext<I, O>,
-) => O | Promise<O>;
-
-export type AsyncMiddlewares<I = unknown, O = unknown> = AsyncMiddleware<
-  I,
-  O
->[];
-
-const ASYNC_PIPELINE_SYMBOL = Symbol('ASYNC_PIPELINE_SYMBOL');
-export const isAsyncPipeline = (input: any): input is AsyncPipeline =>
-  Boolean(input?.[ASYNC_PIPELINE_SYMBOL]);
-
-export type RunAsyncPipelineOptions<I = unknown, O = unknown> = {
-  container?: Container;
-  onLast?: (input: I) => O | Promise<O>;
-};
-
-export type AsyncMiddlewareInput<I = unknown, O = unknown> =
-  | AsyncMiddleware<I, O>
-  | { middleware: AsyncMiddleware<I, O> };
-
-export type AsyncMiddlewareType<T extends AsyncMiddlewareInput> =
-  T extends AsyncMiddlewareInput<infer I, infer O>
-    ? AsyncMiddleware<I, O>
-    : never;
-
-export const getAsyncMiddleware = <I, O>(input: AsyncMiddlewareInput<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 AsyncPipeline<I = unknown, O = unknown> = {
-  [ASYNC_PIPELINE_SYMBOL]: true;
-  use: (...inputs: AsyncMiddlewareInput<I, O>[]) => AsyncPipeline<I, O>;
-  run: (input: I, options?: RunAsyncPipelineOptions<I, O>) => Promise<O>;
-  middleware: AsyncMiddleware<I, O>;
-};
-
-export const createAsyncPipeline = <I, O>(options?: PipelineOptions) => {
-  const config = { ...options };
-
-  const middlewares: AsyncMiddlewares<I, O> = [];
-
-  const use: AsyncPipeline<I, O>['use'] = (...inputs) => {
-    middlewares.push(...inputs.map(getAsyncMiddleware));
-    return pipeline;
-  };
-
-  const createCurrentCounter = (
-    hooks: Hooks,
-    onLast?: (input: I) => O | Promise<O>,
-  ) =>
-    createAsyncCounter<I, O>(async (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 = await runHooks(async () => 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: AsyncPipeline<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: AsyncPipeline<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: AsyncPipeline<I, O> = {
-    [ASYNC_PIPELINE_SYMBOL]: true,
-    use,
-    run,
-    middleware,
-  };
-
-  return pipeline;
-};
-
-export type AsyncPipelineInput<T extends AsyncPipeline> =
-  T extends AsyncPipeline<infer I> ? I : never;
-
-export type AsyncPipelineOutput<T extends AsyncPipeline> =
-  T extends AsyncPipeline<any, infer O> ? O : never;
-
-export const useAsyncPipeline = <I, O>(pipeline: AsyncPipeline<I, O>) => {
-  const container = useContainer();
-
-  const runPipeline = (
-    input: I,
-    options?: RunAsyncPipelineOptions<I, O>,
-  ): Promise<O> => pipeline.run(input, { ...options, container });
-
-  return runPipeline;
-};

package/src/pipeline/index.ts

@@ -1,2 +0,0 @@
-export * from './sync';
-export * from './async';

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;
-};