update types

Author: ricardo-devis-agullo

src/cli/domain/handle-dependencies/ensure-compiler-is-declared-as-devDependency.ts

@@ -7,7 +7,7 @@ export default function ensureCompilerIsDeclaredAsDevDependency(
     template: string;
   },
   cb: Callback<string, string>
-) {
+): void {
   const { componentPath, pkg, template } = options;
   const compilerDep = `${template}-compiler`;
   const isOk = pkg.devDependencies[compilerDep];

src/cli/domain/handle-dependencies/get-compiler.ts

@@ -12,7 +12,7 @@ export default function getCompiler(
     pkg: { name: string; devDependencies: Dictionary<string> };
   },
   cb: Callback<string, string | number>
-) {
+): void {
   const { compilerDep, componentPath, logger, pkg } = options;
   const compilerPath = path.join(componentPath, 'node_modules', compilerDep);
   const compiler = cleanRequire(compilerPath, { justTry: true });

src/cli/domain/handle-dependencies/get-missing-dependencies.ts

@@ -3,7 +3,7 @@ import moduleExists from '../../../utils/module-exists';
 
 export default function getMissingDependencies(
   dependencies: Record<string, string> = {}
-) {
+): string[] {
   const missing: string[] = [];
 
   Object.entries(dependencies).forEach(([dependency, version]) => {

src/cli/domain/handle-dependencies/index.ts

@@ -11,6 +11,7 @@ import linkMissingDependencies from './link-missing-dependencies';
 import isTemplateLegacy from '../../../utils/is-template-legacy';
 import strings from '../../../resources';
 import { Logger } from '../../logger';
+import { Component } from '../../../types';
 
 const getComponentPackageJson = (componentPath: string, cb: Callback<any>) =>
   fs.readJson(path.join(componentPath, 'package.json'), cb);
@@ -24,29 +25,43 @@ export default function handleDependencies(
   callback: Callback<
     {
       modules: string[];
-      templates: Function[];
+      templates: Array<(...args: unknown[]) => unknown>;
     },
     string
   >
-) {
+): void {
   const { components, logger, useComponentDependencies } = options;
 
-  const dependencies = {};
+  const dependencies: Dictionary<string> = {};
   const addDependencies = (componentDependencies: Dictionary<string>) =>
     _.each(componentDependencies || {}, (version, dependency) => {
       dependencies[dependency] = version;
     });
 
-  const templates: Dictionary<Function> = {};
-  const addTemplate = (templateName: string, template: Function) => {
+  const templates: Dictionary<(...args: unknown[]) => unknown> = {};
+  const addTemplate = (
+    templateName: string,
+    template: (...args: unknown[]) => unknown
+  ) => {
     templates[templateName] = template;
   };
 
-  const setupComponentDependencies = (componentPath: string, done) =>
+  const setupComponentDependencies = (
+    componentPath: string,
+    done: (err?: unknown) => void
+  ) =>
     async.waterfall(
       [
-        cb => getComponentPackageJson(componentPath, cb),
-        (pkg, cb) => {
+        (cb: Callback<Component>) => getComponentPackageJson(componentPath, cb),
+        (
+          pkg: Component,
+          cb: Callback<{
+            componentPath: string;
+            logger: Logger;
+            pkg: Component;
+            template: string;
+          }>
+        ) => {
           addDependencies(pkg.dependencies);
 
           const template = pkg.oc.files.template.type;
@@ -57,17 +72,40 @@ export default function handleDependencies(
           cb(null, { componentPath, logger, pkg, template });
         },
 
-        (options, cb) =>
+        (
+          options: {
+            componentPath: string;
+            logger: Logger;
+            pkg: Component;
+            template: string;
+          },
+          cb: any
+        ) =>
           ensureCompilerIsDeclaredAsDevDependency(options, (err, compilerDep) =>
             cb(err, _.extend(options, { compilerDep }))
           ),
 
-        (options, cb) =>
+        (
+          options: {
+            componentPath: string;
+            logger: Logger;
+            pkg: Component;
+            template: string;
+            compilerDep: string;
+          },
+          cb: any
+        ) =>
           getCompiler(options, (err, compiler) =>
             cb(err, _.extend(options, { compiler }))
           ),
 
-        (options, cb) => {
+        (
+          options: {
+            compiler: (...args: unknown[]) => unknown;
+            template: string;
+          },
+          cb: any
+        ) => {
           const { compiler, template } = options;
           addTemplate(template, compiler);
           cb();
@@ -79,7 +117,7 @@ export default function handleDependencies(
   logger.warn(strings.messages.cli.CHECKING_DEPENDENCIES);
   async.eachSeries(components, setupComponentDependencies, err => {
     if (err) {
-      return callback(err, undefined as any);
+      return callback(err as any, undefined as any);
     }
 
     const result = {

src/cli/domain/handle-dependencies/install-compiler.ts

@@ -12,7 +12,7 @@ export default function installCompiler(
     logger: Logger;
   },
   cb: Callback<string, string | number>
-) {
+): void {
   const { compilerPath, componentPath, dependency, logger } = options;
 
   logger.warn(strings.messages.cli.INSTALLING_DEPS(dependency), true);

src/cli/domain/handle-dependencies/install-missing-dependencies.ts

@@ -1,5 +1,3 @@
-'use strict';
-
 import path from 'path';
 
 import getMissingDependencies from './get-missing-dependencies';
@@ -10,7 +8,7 @@ import { Logger } from '../../logger';
 export default function installMissingDependencies(
   options: { dependencies: Dictionary<string>; logger: Logger },
   callback: (err: string | null) => void
-) {
+): void {
   const { dependencies, logger } = options;
 
   const missing = getMissingDependencies(dependencies);

src/cli/domain/handle-dependencies/link-missing-dependencies.ts

@@ -1,4 +1,3 @@
-import _ from 'lodash';
 import path from 'path';
 import fs from 'fs-extra';
 import getMissingDependencies from './get-missing-dependencies';
@@ -13,7 +12,7 @@ export default function linkMissingDependencies(
     logger: Logger;
   },
   callback: (err: string | null) => void
-) {
+): void {
   const { componentPath, dependencies, logger } = options;
 
   const missingDependencies = getMissingDependencies(dependencies);
@@ -42,7 +41,9 @@ export default function linkMissingDependencies(
       fs.ensureSymlinkSync(pathToComponentModule, pathToModule, symLinkType);
     } catch (err) {
       symLinkError = true;
-      logger.err(strings.errors.cli.DEPENDENCY_LINK_FAIL(moduleName, err));
+      logger.err(
+        strings.errors.cli.DEPENDENCY_LINK_FAIL(moduleName, String(err))
+      );
     }
   }
 

src/cli/domain/handle-dependencies/require-template.ts

@@ -1,18 +1,32 @@
-'use strict';
-
 import path from 'path';
 
 import cleanRequire from '../../../utils/clean-require';
 import isTemplateLegacy from '../../../utils/is-template-legacy';
 import isTemplateValid from '../../../utils/is-template-valid';
 import strings from '../../../resources';
+import { Component } from '../../../types';
+
+interface Template {
+  compile: (
+    opts: {
+      publishPath: string;
+      componentPath: string;
+      componentPackage: any;
+      ocPackage: any;
+      minify: boolean;
+      verbose: boolean;
+      production: boolean | undefined;
+    },
+    cb: Callback<Component>
+  ) => void;
+}
 
 export default function requireTemplate(
   template: string,
   options: { compiler: boolean; componentPath: string }
-) {
+): Template {
   const requireOptions = options || {};
-  let ocTemplate;
+  let ocTemplate: Template | undefined;
 
   if (isTemplateLegacy(template)) {
     template = `oc-template-${template}`;