@modern-js/plugin 1.2.0 → 1.3.1

package/src/manager/async.ts

@@ -1,248 +0,0 @@
-import { runWithContainer, createContainer } from 'farrow-pipeline';
-import {
-  ProgressRecord,
-  Progresses2Threads,
-  Progresses2Runners,
-  PluginOptions,
-  ClearDraftProgress,
-  InitOptions,
-  generateRunner,
-  hasOwnProperty,
-  DEFAULT_OPTIONS,
-} from './sync';
-import { useRunner } from './runner';
-
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-export type AsyncInitializer<O> = () => void | O | Promise<O | void>;
-
-const ASYNC_PLUGIN_SYMBOL = 'ASYNC_PLUGIN_SYMBOL';
-
-export type AsyncPlugin<O> = {
-  initializer: AsyncInitializer<O>;
-  ASYNC_PLUGIN_SYMBOL: typeof ASYNC_PLUGIN_SYMBOL;
-} & Required<PluginOptions>;
-
-export type IndexAsyncPlugin<O> = AsyncPlugin<O> & {
-  index: number;
-};
-
-export type AsyncPlugins<O> = AsyncPlugin<O>[];
-export type AsyncIndexPlugins<O> = IndexAsyncPlugin<O>[];
-
-export type AsyncPluginFromAsyncManager<M extends AsyncManager<any, any>> =
-  M extends AsyncManager<infer EP, infer PR>
-    ? AsyncPlugin<Partial<Progresses2Threads<PR & ClearDraftProgress<EP>>>>
-    : never;
-
-export type PluginFromAsyncManager<M extends AsyncManager<any, any>> =
-  M extends AsyncManager<infer EP, infer PR>
-    ? AsyncPlugin<Partial<Progresses2Threads<PR & ClearDraftProgress<EP>>>>
-    : never;
-
-export type AsyncManager<
-  EP extends Record<string, any>,
-  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-  PR extends ProgressRecord | void = void,
-> = {
-  createPlugin: (
-    initializer: AsyncInitializer<
-      Partial<Progresses2Threads<PR & ClearDraftProgress<EP>>>
-    >,
-    options?: PluginOptions,
-  ) => AsyncPlugin<Partial<Progresses2Threads<PR & ClearDraftProgress<EP>>>>;
-  isPlugin: (
-    input: Record<string, unknown>,
-  ) => input is AsyncPlugin<
-    Partial<Progresses2Threads<PR & ClearDraftProgress<EP>>>
-  >;
-  usePlugin: (
-    ...input: AsyncPlugins<
-      Partial<Progresses2Threads<PR & ClearDraftProgress<EP>>>
-    >
-  ) => AsyncManager<EP, PR>;
-  init: (
-    options?: InitOptions,
-  ) => Promise<Progresses2Runners<PR & ClearDraftProgress<EP>>>;
-  run: <O>(cb: () => O, options?: InitOptions) => O;
-  registe: (newShape: Partial<EP>) => void;
-  clone: () => AsyncManager<EP, PR>;
-  clear: () => void;
-  useRunner: () => Progresses2Runners<PR & ClearDraftProgress<EP>>;
-};
-
-export const createAsyncManager = <
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  EP extends Record<string, any> = {},
-  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-  PR extends ProgressRecord | void = void,
->(
-  processes?: PR,
-): AsyncManager<EP, PR> => {
-  let index = 0;
-  const createPlugin: AsyncManager<EP, PR>['createPlugin'] = (
-    initializer,
-    options = {},
-  ) => ({
-    ...DEFAULT_OPTIONS,
-    name: `No.${index++} plugin`,
-    ...options,
-    ASYNC_PLUGIN_SYMBOL,
-    initializer,
-  });
-
-  const isPlugin: AsyncManager<EP, PR>['isPlugin'] = (
-    input,
-  ): input is AsyncPlugin<
-    Partial<Progresses2Threads<PR & ClearDraftProgress<EP>>>
-  > =>
-    hasOwnProperty(input, ASYNC_PLUGIN_SYMBOL) &&
-    input[ASYNC_PLUGIN_SYMBOL] === ASYNC_PLUGIN_SYMBOL;
-
-  const registe: AsyncManager<EP, PR>['registe'] = extraProcesses => {
-    // eslint-disable-next-line no-param-reassign
-    processes = {
-      ...extraProcesses,
-      ...processes,
-    } as any;
-  };
-
-  const clone = () => {
-    let plugins: AsyncIndexPlugins<
-      Partial<Progresses2Threads<PR & ClearDraftProgress<EP>>>
-    > = [];
-
-    const usePlugin: AsyncManager<EP, PR>['usePlugin'] = (...input) => {
-      for (const plugin of input) {
-        if (isPlugin(plugin)) {
-          if (!includeAsyncPlugin(plugins, plugin)) {
-            plugins.push({
-              ...plugin,
-              index: plugins.length,
-            });
-          }
-        } else {
-          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-          // @ts-expect-error
-          console.warn(`Unknown plugin: ${plugin.name}`);
-        }
-      }
-
-      return manager;
-    };
-
-    const clear = () => {
-      plugins = [];
-    };
-
-    const currentContainer = createContainer();
-
-    const init: AsyncManager<EP, PR>['init'] = async options => {
-      const container = options?.container || currentContainer;
-
-      const sortedPlugins = sortAsyncPlugins(plugins);
-
-      checkAsyncPlugins(sortedPlugins);
-
-      const hooksList = await Promise.all(
-        sortedPlugins.map(plugin =>
-          runWithContainer(() => plugin.initializer(), container),
-        ),
-      );
-
-      return generateRunner<EP, PR>(hooksList, container, processes);
-    };
-
-    const run: AsyncManager<EP, PR>['run'] = (cb, options) => {
-      const container = options?.container || currentContainer;
-
-      return runWithContainer(cb, container);
-    };
-
-    const manager = {
-      createPlugin,
-      isPlugin,
-      usePlugin,
-      init,
-      run,
-      clear,
-      clone,
-      registe,
-      useRunner,
-    };
-
-    return manager;
-  };
-
-  return clone();
-};
-
-const includeAsyncPlugin = <O>(
-  plugins: AsyncPlugins<O>,
-  input: AsyncPlugin<O>,
-): boolean => {
-  for (const plugin of plugins) {
-    if (plugin.name === input.name) {
-      return true;
-    }
-  }
-
-  return false;
-};
-
-const sortAsyncPlugins = <O>(
-  input: AsyncIndexPlugins<O>,
-): AsyncIndexPlugins<O> => {
-  let plugins = input.slice();
-
-  for (let i = 0; i < plugins.length; i++) {
-    const plugin = plugins[i];
-
-    for (const pre of plugin.pre) {
-      for (let j = i + 1; j < plugins.length; j++) {
-        if (plugins[j].name === pre) {
-          plugins = [
-            ...plugins.slice(0, i),
-            plugins[j],
-            ...plugins.slice(i, j),
-            ...plugins.slice(j + 1, plugins.length),
-          ];
-        }
-      }
-    }
-
-    for (const post of plugin.post) {
-      for (let j = 0; j < i; j++) {
-        if (plugins[j].name === post) {
-          plugins = [
-            ...plugins.slice(0, j),
-            ...plugins.slice(j + 1, i + 1),
-            plugins[j],
-            ...plugins.slice(i + 1, plugins.length),
-          ];
-        }
-      }
-    }
-  }
-
-  return plugins;
-};
-
-const checkAsyncPlugins = <O>(plugins: AsyncIndexPlugins<O>) => {
-  for (const origin of plugins) {
-    for (const rival of origin.rivals) {
-      for (const plugin of plugins) {
-        if (rival === plugin.name) {
-          throw new Error(`${origin.name} has rival ${plugin.name}`);
-        }
-      }
-    }
-
-    for (const required of origin.required) {
-      if (!plugins.some(plugin => plugin.name === required)) {
-        throw new Error(
-          `The plugin: ${required} is required when plugin: ${origin.name} is exist.`,
-        );
-      }
-    }
-  }
-};

package/src/manager/index.ts

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

package/src/manager/runner.ts

@@ -1,15 +0,0 @@
-import { createContext } from 'farrow-pipeline';
-
-export const RunnerContext = createContext<any>(null);
-
-export const useRunner = () => {
-  const runner = RunnerContext.use().value;
-
-  if (!runner) {
-    throw new Error(
-      `Can't call useRunner out of scope, it should be placed in hooks of plugin`,
-    );
-  }
-
-  return runner;
-};