chore(typescript): update types

Author: Ovidiu Barabula

types/config-wizard/index.d.ts

@@ -17,12 +17,6 @@ export interface QuestionnaireAnswers {
 }
 export declare type QuestionnaireSubscriber = (defaults: Config, questionnaire: ConfigQuestionnaire) => Promise<boolean | Error>;
 export interface IConfigWizard {
-    getQuestionnaires?(): Questionnaires;
-    startQuestionnaire?(namespace: string): Promise<Config>;
-    validateQuestionnaire?(questionnaire: ConfigQuestionnaire): boolean;
-    isConfigured?(pluginName: string, defaults: Config): Promise<boolean>;
-    getConfiguration?(namespace: string, defaults: Config): Promise<Config>;
-    setConfiguration?(namespace: string, config: Config): Promise<boolean | Error>;
     addQuestionnaire(...items: ConfigQuestionnaire[]): boolean;
     getSubscriber(): QuestionnaireSubscriber;
     start(): Config;

types/dependencies-manager/dependencies-installer.d.ts

@@ -0,0 +1,40 @@
+export declare type PackageManager = 'yarn' | 'npm';
+export declare type PackageManagersList = PackageManager[] | string[];
+export interface NodeDependencies {
+    [key: string]: string;
+}
+export interface DependenciesManifest {
+    [key: string]: any;
+    devDependencies?: NodeDependencies;
+    dependencies?: NodeDependencies;
+}
+export interface DependenciesInstallerOptions {
+    logChannel?: string;
+    managers?: PackageManagersList;
+}
+export interface DependenciesInstallerDefaults {
+    logChannel: string;
+    managers: PackageManagersList;
+}
+export interface DependenciesInstaller {
+    add(manifest: DependenciesManifest): Promise<void>;
+    run(): Promise<void>;
+}
+export declare const ERRORS: {
+    CWD_INVALID: string;
+    DEPENDENCY_ALREADY_ADDED: string;
+    DEPENDENCY_VERSION_MISMATCH: string;
+    MANAGERS_REQUIRED: string;
+    MANIFEST_INVALID: string;
+    NO_MANAGERS: string;
+};
+/**
+ * Dependencies Installer
+ * @param cwd Current working directory path
+ * @param options Options object
+ */
+export declare function Installer(cwd?: string, options?: DependenciesInstallerOptions): Promise<DependenciesInstaller>;
+declare const _default: Readonly<{
+    getInstance: (cwd: string, options?: DependenciesInstallerOptions | undefined) => Promise<DependenciesInstaller>;
+}>;
+export default _default;

types/dependencies-manager/index.d.ts

@@ -0,0 +1,16 @@
+import { DependenciesManifest } from './dependencies-installer';
+export declare type DependenciesSubscriber = (manifest: DependenciesManifest, name: string) => void;
+export interface DependenceisManifests {
+    [key: string]: DependenciesManifest;
+}
+export interface DependenciesManager {
+    getSubscriber(): DependenciesSubscriber;
+    install(): Promise<void>;
+}
+/**
+ * DependenciesManager constructor
+ * The manager will act as a middle-man to delay the (taxing) Dependencies Installer instatiation
+ */
+export declare function DependenciesManager(): DependenciesManager;
+declare const _default: DependenciesManager;
+export default _default;

types/plugin-manager/index.d.ts

@@ -1,4 +1,5 @@
 import { IConfigWizard, QuestionnaireSubscriber } from '../config-wizard';
+import { DependenciesManager, DependenciesSubscriber } from '../dependencies-manager';
 import { TaskManager, TaskSubscriber } from '../task-manager';
 import { InstallableObject } from './installable';
 export interface Plugin {
@@ -8,19 +9,18 @@ export interface Plugin {
 }
 export interface PluginManager {
     use(...plugin: Array<string | Plugin | InstallableObject>): Promise<void>;
-    loadPlugin?(name: string): any;
-    parsePlugins?(plugins: PluginsArray): Promise<Plugin[]>;
 }
 export declare type PluginsArray = Array<string | Plugin | InstallableObject>;
-export declare type PluginSubscribers = TaskSubscriber | QuestionnaireSubscriber;
+export declare type PluginSubscribers = TaskSubscriber | QuestionnaireSubscriber | DependenciesSubscriber;
 export declare const ERRORS: {
     NO_CONFIG_WIZARD: string;
+    NO_DEPS_MANAGER: string;
     NO_TASK_MANAGER: string;
     PLUGIN_NAME_SHOULD_BE_STRING: string;
     PLUGIN_NOT_FOUND: string;
 };
 /**
  * PluginManager constructor
  */
-declare function PluginManager(taskManager: TaskManager, configWizard: IConfigWizard): PluginManager;
+declare function PluginManager(taskManager: TaskManager, configWizard: IConfigWizard, depsManager: DependenciesManager): PluginManager;
 export default PluginManager;

types/plugin-manager/installable.d.ts

@@ -1,13 +1,15 @@
 import { Config, IConfigManager } from '../config-manager';
 import { ConfigQuestionnaire } from '../config-wizard';
+import { DependenciesManifest } from '../dependencies-manager/dependencies-installer';
 import { ILogger } from '../util/logger';
-import { AnyFunction } from '../util/utility-functions';
+import { AnyFunction, AnyObject } from '../util/utility-functions';
 import { Plugin } from './index';
 import { WorkingPaths } from './paths';
 export interface InstallableObject {
     taskFn: AnyFunction;
     hook: string;
     name: string;
+    dependencies?: DependenciesManifest;
     description?: string;
     configDefaults?: Config;
     configQuestionnaire?: ConfigQuestionnaire;
@@ -30,9 +32,7 @@ export declare const ERRORS: {
  * Check if object is an installable Plugin
  * @param object Plugin object to be tested
  */
-export declare function isInstallable(object: {
-    [key: string]: any;
-}): boolean | void;
+export declare function isInstallable(object: AnyObject): boolean | void;
 /**
  * Create utilities provider (e.g. logger, config proxy, paths, etc.)
  * @param name Plugin name
@@ -46,12 +46,13 @@ export declare function getUtilitiesProvider(name: string): Promise<PluginProvid
 export declare function provideUtilities(taskFn: AnyFunction, name: string): Promise<AnyFunction>;
 /**
  * Installable plugin factory
- * @param { configDefaults } Configuration defaults object
- * @param { configQuestionnaire } Configuration questionnaire object
- * @param { description } Task description
- * @param { hook } Task registration hook
- * @param { name } Task name
- * @param { taskFn } Function to be called when running the task
+ * @param configDefaults Configuration defaults object
+ * @param configQuestionnaire Configuration questionnaire object
+ * @param dependencies Dependencies manifest object
+ * @param description Task description
+ * @param hook Task registration hook
+ * @param name Task name
+ * @param taskFn Function to be called when running the task
  */
 declare function Installable(plugin: Plugin | InstallableObject): Plugin;
 export default Installable;

types/task-manager/index.d.ts

@@ -7,10 +7,6 @@ export interface TaskSubscriber {
 export interface TaskManager {
     run(hook: string): Promise<boolean>;
     getSubscribers(): TaskSubscriber;
-    subscribe?(task: string, hook: string): boolean;
-    hasTasks?(hook: string): boolean;
-    getTasks?(): Tasks;
-    getHooks?(): string[];
 }
 export interface TaskManagerOptions {
     [key: string]: any;

types/tasks/index.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Name: index.ts
+ * Description: Import all tasks and export as single tasks array
+ * Author: Ovidiu Barabula <lectii2008@gmail.com>
+ * @since 1.1.0
+ */
+import { PluginProvider } from '../plugin-manager/installable';
+declare const tasks: ({
+    configDefaults: {
+        buildDir: string;
+        plugins: never[];
+        sourceDir: string;
+    };
+    configQuestionnaire: {
+        namespace: string;
+        questions: ({
+            default: string;
+            message: string;
+            name: string;
+            type: string;
+            choices?: undefined;
+        } | {
+            choices: string[];
+            message: string;
+            name: string;
+            type: string;
+            default?: undefined;
+        })[];
+    };
+    description: string;
+    hook: string;
+    name: string;
+    taskFn: (done: (...args: any[]) => any, { config, logger }: PluginProvider) => Promise<any>;
+} | {
+    description: string;
+    hook: string;
+    name: string;
+    taskFn: (done: (...args: any[]) => any, { config, logger }: PluginProvider) => Promise<void>;
+})[];
+export default tasks;

types/tasks/task-init-project.d.ts

@@ -1,10 +1,5 @@
 import { PluginProvider } from '../plugin-manager/installable';
 import { AnyFunction } from '../util/utility-functions';
-declare const configDefaults: {
-    buildDir: string;
-    plugins: never[];
-    sourceDir: string;
-};
 declare const taskExport: {
     configDefaults: {
         buildDir: string;
@@ -30,13 +25,6 @@ declare const taskExport: {
     description: string;
     hook: string;
     name: string;
-    taskFn: typeof taskFn;
+    taskFn: (done: AnyFunction, { config, logger }: PluginProvider) => Promise<any>;
 };
-/**
- * Task main function
- * @param done Gulp async callback
- * @param pluginProvider Assortment of tools for plugins and tasks (e.g. logger, config manager, etc.)
- */
-declare function taskFn(done: AnyFunction, {config, logger}: PluginProvider): Promise<any>;
-export { taskFn, configDefaults };
 export default taskExport;

types/tasks/task-install-dependencies.d.ts

@@ -0,0 +1,9 @@
+import { PluginProvider } from '../plugin-manager/installable';
+import { AnyFunction } from '../util/utility-functions';
+declare const taskExport: {
+    description: string;
+    hook: string;
+    name: string;
+    taskFn: (done: AnyFunction, { config, logger }: PluginProvider) => Promise<void>;
+};
+export default taskExport;

types/util/dependencies-installer.d.ts

@@ -0,0 +1,40 @@
+export declare type PackageManager = 'yarn' | 'npm';
+export declare type PackageManagersList = PackageManager[] | string[];
+export interface NodeDependencies {
+    [key: string]: string;
+}
+export interface DependenciesManifest {
+    [key: string]: any;
+    devDependencies?: NodeDependencies;
+    dependencies?: NodeDependencies;
+}
+export interface DependenciesInstallerOptions {
+    logChannel?: string;
+    managers?: PackageManagersList;
+}
+export interface DependenciesInstallerDefaults {
+    logChannel: string;
+    managers: PackageManagersList;
+}
+export interface DependenciesInstaller {
+    add(manifest: DependenciesManifest): Promise<void>;
+    run(): Promise<void>;
+}
+export declare const ERRORS: {
+    CWD_INVALID: string;
+    DEPENDENCY_ALREADY_ADDED: string;
+    DEPENDENCY_VERSION_MISMATCH: string;
+    MANAGERS_REQUIRED: string;
+    MANIFEST_INVALID: string;
+    NO_MANAGERS: string;
+};
+/**
+ * Dependencies Installer
+ * @param cwd Current working directory path
+ * @param options Options object
+ */
+export declare function Installer(cwd?: string, options?: DependenciesInstallerOptions): Promise<DependenciesInstaller>;
+declare const _default: Readonly<{
+    getInstance: (cwd: string, options?: DependenciesInstallerOptions | undefined) => Promise<DependenciesInstaller>;
+}>;
+export default _default;