@learnpack/learnpack 2.1.39 → 2.1.40

package/src/models/session.ts

@@ -1,34 +1,34 @@
-import { IConfig, IConfigObj } from "./config"
-
-export interface IPayload {
-  email: string;
-}
-
-export interface IStartProps {
-  token: string;
-  payload: IPayload | null;
-}
-
-type TLoginResponse = {
-  token: string;
-  user_id: string;
-  email: string;
-};
-
-export interface ISession {
-  sessionStarted: boolean;
-  token: string | null;
-  config: IConfig | null;
-  currentCohort: null;
-  initialize: () => Promise<boolean>;
-  setRigoToken: (token: string) => Promise<boolean>;
-  setPayload: (value: IPayload) => Promise<boolean>;
-  getPayload: () => Promise<any>;
-  isActive: () => boolean;
-  get: (config?: IConfigObj) => Promise<any>;
-  login: () => Promise<void>;
-  loginWeb: (email: string, password: string) => Promise<TLoginResponse>;
-  sync: () => Promise<void>;
-  start: ({ token, payload }: IStartProps) => Promise<void>;
-  destroy: () => Promise<void>;
-}
+import { IConfig, IConfigObj } from "./config"
+
+export interface IPayload {
+  email: string;
+}
+
+export interface IStartProps {
+  token: string;
+  payload: IPayload | null;
+}
+
+type TLoginResponse = {
+  token: string;
+  user_id: string;
+  email: string;
+};
+
+export interface ISession {
+  sessionStarted: boolean;
+  token: string | null;
+  config: IConfig | null;
+  currentCohort: null;
+  initialize: () => Promise<boolean>;
+  setRigoToken: (token: string) => Promise<boolean>;
+  setPayload: (value: IPayload) => Promise<boolean>;
+  getPayload: () => Promise<any>;
+  isActive: () => boolean;
+  get: (config?: IConfigObj) => Promise<any>;
+  login: () => Promise<void>;
+  loginWeb: (email: string, password: string) => Promise<TLoginResponse>;
+  sync: () => Promise<void>;
+  start: ({ token, payload }: IStartProps) => Promise<void>;
+  destroy: () => Promise<void>;
+}

package/src/models/socket.ts

@@ -52,3 +52,8 @@ export interface ISocket {
   success: (type: any, stdout: string) => void;
   onTestingFinished: (obj: any) => void;
 }
+
+export type TOpenWindowData = {
+  url: string;
+  exerciseSlug: string;
+};

package/src/models/status.ts

@@ -1,16 +1,16 @@
-export type TStatus =
-  | "ready"
-  | "internal-error"
-  | "compiler-success"
-  | "testing-success"
-  | "compiling"
-  | "testing"
-  | "start_exercise"
-  | "initializing"
-  | "configuration_loaded"
-  | "connection_ended"
-  | "reset_exercise"
-  | "open_files"
-  | "open_window"
-  | "instructions_closed"
-  | "completed";
+export type TStatus =
+  | "ready"
+  | "internal-error"
+  | "compiler-success"
+  | "testing-success"
+  | "compiling"
+  | "testing"
+  | "start_exercise"
+  | "initializing"
+  | "configuration_loaded"
+  | "connection_ended"
+  | "reset_exercise"
+  | "open_files"
+  | "open_window"
+  | "instructions_closed"
+  | "completed";

package/src/models/success-types.ts

@@ -1 +1 @@
-export type TSuccessType = 'compiler-success' | 'testing-success';
+export type TSuccessType = 'compiler-success' | 'testing-success';

package/src/plugin/command/compile.ts

@@ -1,17 +1,17 @@
-import { IError } from "../../models/errors"
-
-const CompilationError = (messages: string) => {
-  const _err: IError = new Error(messages)
-  _err.status = 400
-  _err.stdout = messages
-  _err.type = "compiler-error"
-  return _err
-}
-
-export default {
-  CompilationError,
-  default: async ({ action, ...rest }: any) => {
-    const stdout = await action.run(rest)
-    return stdout
-  },
-}
+import { IError } from "../../models/errors"
+
+const CompilationError = (messages: string) => {
+  const _err: IError = new Error(messages)
+  _err.status = 400
+  _err.stdout = messages
+  _err.type = "compiler-error"
+  return _err
+}
+
+export default {
+  CompilationError,
+  default: async ({ action, ...rest }: any) => {
+    const stdout = await action.run(rest)
+    return stdout
+  },
+}

package/src/plugin/command/test.ts

@@ -1,30 +1,30 @@
-import * as fs from "fs"
-import { IError } from "../../models/errors"
-
-const TestingError = (messages: string) => {
-  const _err: IError = new Error(messages)
-  _err.status = 400
-  _err.stdout = messages
-  _err.type = "testing-error"
-  return _err
-}
-
-export default {
-  TestingError,
-  default: async function (args: any) {
-    const { action, configuration, socket, exercise } = args
-
-    if (!fs.existsSync(`${configuration.dirPath}/reports`)) {
-      // reports directory
-      fs.mkdirSync(`${configuration.dirPath}/reports`)
-    }
-
-    // compile
-    const stdout = await action.run(args)
-
-    // mark exercise as done
-    exercise.done = true
-
-    return stdout
-  },
-}
+import * as fs from "fs"
+import { IError } from "../../models/errors"
+
+const TestingError = (messages: string) => {
+  const _err: IError = new Error(messages)
+  _err.status = 400
+  _err.stdout = messages
+  _err.type = "testing-error"
+  return _err
+}
+
+export default {
+  TestingError,
+  default: async function (args: any) {
+    const { action, configuration, socket, exercise } = args
+
+    if (!fs.existsSync(`${configuration.dirPath}/reports`)) {
+      // reports directory
+      fs.mkdirSync(`${configuration.dirPath}/reports`)
+    }
+
+    // compile
+    const stdout = await action.run(args)
+
+    // mark exercise as done
+    exercise.done = true
+
+    return stdout
+  },
+}

package/src/plugin/index.ts

@@ -1,6 +1,6 @@
-import CompilationError from "./command/compile"
-import TestingError from "./command/test"
-import utils from "./utils"
-import plugin from "./plugin"
-
-export default { CompilationError, TestingError, Utils: utils, plugin }
+import CompilationError from "./command/compile"
+import TestingError from "./command/test"
+import utils from "./utils"
+import plugin from "./plugin"
+
+export default { CompilationError, TestingError, Utils: utils, plugin }

package/src/plugin/plugin.ts

@@ -1,94 +1,94 @@
-import * as shell from "shelljs"
-import { IPluginConfig } from "../models/plugin-config"
-/**
- * Main Plugin Runner, it defines the behavior of a learnpack plugin
- * dividing it in "actions" like: Compile, test, etc.
- * @param {object} pluginConfig Configuration object that must defined language and each possible action.
- */
-export default (pluginConfig: IPluginConfig) => {
-  return async (args: any) => {
-    const { action, exercise, socket, configuration } = args
-
-    if (pluginConfig.language === undefined)
-      throw new Error(`Missing language on the plugin configuration object`)
-
-    if (typeof action !== "string") {
-      throw new TypeError("Missing action property on hook details")
-    }
-
-    if (!exercise || exercise === undefined) {
-      throw new Error("Missing exercise information")
-    }
-
-    type actionType = "compile" | "test";
-
-    // if the action does not exist I don't do anything
-    if (pluginConfig[action as actionType] === undefined) {
-      console.log(`Ignoring ${action}`)
-      return () => null
-    }
-
-    // ignore if the plugin language its not the same as the exercise language
-    if (exercise.language !== pluginConfig.language) {
-      return () => null
-    }
-
-    if (!exercise.files || exercise.files.length === 0) {
-      throw new Error(`No files to process`)
-    }
-
-    try {
-      const _action = pluginConfig[action as actionType]
-
-      if (_action === null || typeof _action !== "object")
-        throw new Error(
-          `The ${pluginConfig.language} ${action} module must export an object configuration`
-        )
-      if (_action.validate === undefined)
-        throw new Error(
-          `Missing validate method for ${pluginConfig.language} ${action}`
-        )
-      if (_action.run === undefined)
-        throw new Error(
-          `Missing run method for ${pluginConfig.language} ${action}`
-        )
-      if (_action.dependencies !== undefined) {
-        if (!Array.isArray(_action.dependencies))
-          throw new Error(
-            `${action}.dependencies must be an array of package names`
-          )
-
-        for (const packageName of _action.dependencies) {
-          if (!shell.which(packageName)) {
-            throw new Error(
-              `🚫 You need to have ${packageName} installed to run test the exercises`
-            )
-          }
-        }
-      }
-
-      const valid = await _action.validate({ exercise, configuration })
-      if (valid) {
-        // look for the command standard implementation and execute it
-        const execute = require("./command/" + action + ".js").default
-        // no matter the command, the response must always be a stdout
-        const stdout = await execute({
-          ...args,
-          action: _action,
-          configuration,
-        })
-
-        // Map the action names to socket messaging standards
-        const actionToSuccessMapper = { compile: "compiler", test: "testing" }
-
-        socket.success(actionToSuccessMapper[action as actionType], stdout)
-        return stdout
-      }
-    } catch (error: any) {
-      if (error.type === undefined) 
-socket.fatal(error)
-      else 
-socket.error(error.type, error.stdout)
-    }
-  }
-}
+import * as shell from "shelljs"
+import { IPluginConfig } from "../models/plugin-config"
+/**
+ * Main Plugin Runner, it defines the behavior of a learnpack plugin
+ * dividing it in "actions" like: Compile, test, etc.
+ * @param {object} pluginConfig Configuration object that must defined language and each possible action.
+ */
+export default (pluginConfig: IPluginConfig) => {
+  return async (args: any) => {
+    const { action, exercise, socket, configuration } = args
+
+    if (pluginConfig.language === undefined)
+      throw new Error(`Missing language on the plugin configuration object`)
+
+    if (typeof action !== "string") {
+      throw new TypeError("Missing action property on hook details")
+    }
+
+    if (!exercise || exercise === undefined) {
+      throw new Error("Missing exercise information")
+    }
+
+    type actionType = "compile" | "test";
+
+    // if the action does not exist I don't do anything
+    if (pluginConfig[action as actionType] === undefined) {
+      console.log(`Ignoring ${action}`)
+      return () => null
+    }
+
+    // ignore if the plugin language its not the same as the exercise language
+    if (exercise.language !== pluginConfig.language) {
+      return () => null
+    }
+
+    if (!exercise.files || exercise.files.length === 0) {
+      throw new Error(`No files to process`)
+    }
+
+    try {
+      const _action = pluginConfig[action as actionType]
+
+      if (_action === null || typeof _action !== "object")
+        throw new Error(
+          `The ${pluginConfig.language} ${action} module must export an object configuration`
+        )
+      if (_action.validate === undefined)
+        throw new Error(
+          `Missing validate method for ${pluginConfig.language} ${action}`
+        )
+      if (_action.run === undefined)
+        throw new Error(
+          `Missing run method for ${pluginConfig.language} ${action}`
+        )
+      if (_action.dependencies !== undefined) {
+        if (!Array.isArray(_action.dependencies))
+          throw new Error(
+            `${action}.dependencies must be an array of package names`
+          )
+
+        for (const packageName of _action.dependencies) {
+          if (!shell.which(packageName)) {
+            throw new Error(
+              `🚫 You need to have ${packageName} installed to run test the exercises`
+            )
+          }
+        }
+      }
+
+      const valid = await _action.validate({ exercise, configuration })
+      if (valid) {
+        // look for the command standard implementation and execute it
+        const execute = require("./command/" + action + ".js").default
+        // no matter the command, the response must always be a stdout
+        const stdout = await execute({
+          ...args,
+          action: _action,
+          configuration,
+        })
+
+        // Map the action names to socket messaging standards
+        const actionToSuccessMapper = { compile: "compiler", test: "testing" }
+
+        socket.success(actionToSuccessMapper[action as actionType], stdout)
+        return stdout
+      }
+    } catch (error: any) {
+      if (error.type === undefined) 
+socket.fatal(error)
+      else 
+socket.error(error.type, error.stdout)
+    }
+  }
+}

package/src/plugin/utils.ts

@@ -1,87 +1,87 @@
-import * as chalk from "chalk"
-
-const getMatches = (reg: RegExp, content: string) => {
-  const inputs = []
-  let m
-  while ((m = reg.exec(content)) !== null) {
-    // This is necessary to avoid infinite loops with zero-width matches
-    if (m.index === reg.lastIndex) 
-reg.lastIndex++
-
-    // The result can be accessed through the `m`-variable.
-    inputs.push(m[1] || null)
-  }
-
-  return inputs
-}
-
-const cleanStdout = (buffer: string, inputs: string[]) => {
-  if (Array.isArray(inputs))
-    for (let i = 0; i < inputs.length; i++)
-      if (inputs[i]) 
-buffer = buffer.replace(inputs[i], "")
-
-  return buffer
-}
-
-const indent = (string: string, options: any, count = 1) => {
-  options = {
-    indent: " ",
-    includeEmptyLines: false,
-    ...options,
-  }
-
-  if (typeof string !== "string") {
-    throw new TypeError(
-      `Expected \`input\` to be a \`string\`, got \`${typeof string}\``
-    )
-  }
-
-  if (typeof count !== "number") {
-    throw new TypeError(
-      `Expected \`count\` to be a \`number\`, got \`${typeof count}\``
-    )
-  }
-
-  if (count < 0) {
-    throw new RangeError(
-      `Expected \`count\` to be at least 0, got \`${count}\``
-    )
-  }
-
-  if (typeof options.indent !== "string") {
-    throw new TypeError(
-      `Expected \`options.indent\` to be a \`string\`, got \`${typeof options.indent}\``
-    )
-  }
-
-  if (count === 0) {
-    return string
-  }
-
-  const regex = options.includeEmptyLines ? /^/gm : /^(?!\s*$)/gm
-
-  return string.replace(regex, options.indent.repeat(count))
-}
-
-const Console = {
-  // _debug: true,
-  _debug: process.env.DEBUG === "true",
-  startDebug: function () {
-    this._debug = true
-  },
-  log: (msg: string, ...args: any[]) => console.log(chalk.gray(msg), ...args),
-  error: (msg: string, ...args: any[]) =>
-    console.log(chalk.red("⨉ " + msg), ...args),
-  success: (msg: string, ...args: any[]) =>
-    console.log(chalk.green("✓ " + msg), ...args),
-  info: (msg: string, ...args: any[]) =>
-    console.log(chalk.blue("ⓘ " + msg), ...args),
-  help: (msg: string) =>
-    console.log(`${chalk.white.bold("⚠ help:")} ${chalk.white(msg)}`),
-  debug(...args: any[]) {
-    this._debug && console.log(chalk.magentaBright(`⚠ debug: `), args)
-  },
-}
-
-export default { getMatches, cleanStdout, indent, Console }
+import * as chalk from "chalk"
+
+const getMatches = (reg: RegExp, content: string) => {
+  const inputs = []
+  let m
+  while ((m = reg.exec(content)) !== null) {
+    // This is necessary to avoid infinite loops with zero-width matches
+    if (m.index === reg.lastIndex) 
+reg.lastIndex++
+
+    // The result can be accessed through the `m`-variable.
+    inputs.push(m[1] || null)
+  }
+
+  return inputs
+}
+
+const cleanStdout = (buffer: string, inputs: string[]) => {
+  if (Array.isArray(inputs))
+    for (let i = 0; i < inputs.length; i++)
+      if (inputs[i]) 
+buffer = buffer.replace(inputs[i], "")
+
+  return buffer
+}
+
+const indent = (string: string, options: any, count = 1) => {
+  options = {
+    indent: " ",
+    includeEmptyLines: false,
+    ...options,
+  }
+
+  if (typeof string !== "string") {
+    throw new TypeError(
+      `Expected \`input\` to be a \`string\`, got \`${typeof string}\``
+    )
+  }
+
+  if (typeof count !== "number") {
+    throw new TypeError(
+      `Expected \`count\` to be a \`number\`, got \`${typeof count}\``
+    )
+  }
+
+  if (count < 0) {
+    throw new RangeError(
+      `Expected \`count\` to be at least 0, got \`${count}\``
+    )
+  }
+
+  if (typeof options.indent !== "string") {
+    throw new TypeError(
+      `Expected \`options.indent\` to be a \`string\`, got \`${typeof options.indent}\``
+    )
+  }
+
+  if (count === 0) {
+    return string
+  }
+
+  const regex = options.includeEmptyLines ? /^/gm : /^(?!\s*$)/gm
+
+  return string.replace(regex, options.indent.repeat(count))
+}
+
+const Console = {
+  // _debug: true,
+  _debug: process.env.DEBUG === "true",
+  startDebug: function () {
+    this._debug = true
+  },
+  log: (msg: string, ...args: any[]) => console.log(chalk.gray(msg), ...args),
+  error: (msg: string, ...args: any[]) =>
+    console.log(chalk.red("⨉ " + msg), ...args),
+  success: (msg: string, ...args: any[]) =>
+    console.log(chalk.green("✓ " + msg), ...args),
+  info: (msg: string, ...args: any[]) =>
+    console.log(chalk.blue("ⓘ " + msg), ...args),
+  help: (msg: string) =>
+    console.log(`${chalk.white.bold("⚠ help:")} ${chalk.white(msg)}`),
+  debug(...args: any[]) {
+    this._debug && console.log(chalk.magentaBright(`⚠ debug: `), args)
+  },
+}
+
+export default { getMatches, cleanStdout, indent, Console }

package/src/types/node-fetch.d.ts

@@ -1 +1 @@
-declare module '*';
+declare module '*';