@adonisjs/repl 3.1.11 → 4.0.0-1

package/build/src/{Repl/index.js → repl.js}

@@ -1,23 +1,15 @@
-"use strict";
 /*
  * @adonisjs/repl
  *
- * (c) Harminder Virk <virk@adonisjs.com>
+ * (c) AdonisJS
  *
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Repl = void 0;
-const vm_1 = require("vm");
-const string_width_1 = __importDefault(require("string-width"));
-const colors_1 = require("@poppinss/colors");
-const repl_1 = require("repl");
-const util_1 = require("util");
-const Compiler_1 = require("../Compiler");
+import useColors from '@poppinss/colors';
+import { Recoverable, start as startRepl } from 'node:repl';
+import stringWidth from 'string-width';
+import { inspect, promisify as utilPromisify } from 'node:util';
 /**
  * List of node global properties to remove from the
  * ls inspect
@@ -32,23 +24,27 @@ const GLOBAL_NODE_PROPERTIES = [
     'queueMicrotask',
     'clearImmediate',
     'setImmediate',
-    'exports',
-    '__importDefault',
+    'structuredClone',
+    'atob',
+    'btoa',
+    'fetch',
+    'crypto',
 ];
-/**
- * Properties injected by the ts-utils
- * library
- */
-const TS_UTIL_HELPERS = [
+const TS_UTILS_HELPERS = [
     '__extends',
     '__assign',
     '__rest',
     '__decorate',
     '__param',
+    '__esDecorate',
+    '__runInitializers',
+    '__propKey',
+    '__setFunctionName',
     '__metadata',
     '__awaiter',
     '__generator',
     '__exportStar',
+    '__createBinding',
     '__values',
     '__read',
     '__spread',
@@ -63,108 +59,74 @@ const TS_UTIL_HELPERS = [
     '__importDefault',
     '__classPrivateFieldGet',
     '__classPrivateFieldSet',
-    '__createBinding',
+    '__classPrivateFieldIn',
 ];
 const icons = process.platform === 'win32' && !process.env.WT_SESSION
-    ? {
-        tick: '√',
-        pointer: '>',
-    }
-    : {
-        tick: '✔',
-        pointer: '❯',
-    };
-/**
- * Exposes the API to work the REPL server
- */
-class Repl {
-    constructor(tsCompiler, historyFilePath) {
-        this.tsCompiler = tsCompiler;
-        this.historyFilePath = historyFilePath;
-        /**
-         * Compiler to compile REPL input
-         */
-        this.compiler = new Compiler_1.Compiler(this.tsCompiler);
-        /**
-         * Length of the longest custom method name. We need to show a
-         * symmetric view of custom methods and their description
-         */
-        this.longestCustomMethodName = 0;
-        /**
-         * Set of registered ready callbacks
-         */
-        this.onReadyCallbacks = [];
-        /**
-         * A set of registered custom methods
-         */
-        this.customMethods = {};
-        /**
-         * Reference to the colors to print colorful messages
-         */
-        this.colors = (0, colors_1.getBest)(false);
-    }
+    ? { tick: '√', pointer: '>' }
+    : { tick: '✔', pointer: '❯' };
+export class Repl {
     /**
-     * Find if the error is recoverable or not
+     * Length of the longest custom method name. We need to show a
+     * symmetric view of custom methods and their description
      */
-    isRecoverableError(error) {
-        if (error.name === 'SyntaxError') {
-            return /^(Unexpected end of input|Unexpected token)/.test(error.message);
-        }
-        return false;
-    }
+    #longestCustomMethodName = 0;
     /**
-     * Custom eval method to execute the user code
+     * Reference to the original `eval` method of the repl server.
+     * Since we are monkey patching it, we need a reference to it
+     * to call it after our custom logic
      */
-    async eval(cmd, _, filename, callback) {
-        try {
-            let response;
-            const { compiled, awaitPromise } = await this.compiler.compile(cmd, filename);
-            if (awaitPromise) {
-                response = await new vm_1.Script(compiled, { filename }).runInThisContext();
-            }
-            else {
-                response = new vm_1.Script(compiled, { filename }).runInThisContext();
-            }
-            callback(null, response);
-        }
-        catch (error) {
-            if (this.isRecoverableError(error)) {
-                callback(new repl_1.Recoverable(error), null);
-                return;
-            }
-            callback(error, null);
-        }
+    #originalEval = null;
+    /**
+     * Compiler that will transform the user input just
+     * before evaluation
+     */
+    #compiler;
+    /**
+     * Set of registered ready callbacks
+     */
+    #onReadyCallbacks = [];
+    /**
+     * A set of registered custom methods
+     */
+    #customMethods = {};
+    /**
+     * Path to the history file
+     */
+    #historyFilePath;
+    /**
+     * Colors reference
+     */
+    colors = useColors.ansi();
+    /**
+     * Reference to the repl server. Available after the `start` method
+     * is invoked
+     */
+    server;
+    constructor(options) {
+        this.#compiler = options?.compiler;
+        this.#historyFilePath = options?.historyFilePath;
     }
-    registerCustomMethodWithContext(name) {
-        const customMethod = this.customMethods[name];
-        if (!customMethod) {
-            return;
-        }
-        /**
-         * Wrap handler
-         */
-        const handler = (...args) => customMethod.handler(this, ...args);
+    /**
+     * Prints the welcome message
+     */
+    #printWelcomeMessage() {
+        console.log('');
         /**
-         * Re-define the function name to be more description
+         * Log about typescript support
          */
-        Object.defineProperty(handler, 'name', { value: customMethod.handler.name });
+        if (this.#compiler?.supportsTypescript) {
+            console.log(`${this.colors.green(icons.tick)} ${this.colors.dim('typescript compilation supported')}`);
+            console.log('');
+        }
         /**
-         * Register with the context
+         * Log about help command
          */
-        this.server.context[name] = handler;
-    }
-    /**
-     * Register custom methods with the server context
-     */
-    registerCustomMethodsWithContext() {
-        Object.keys(this.customMethods).forEach((name) => {
-            this.registerCustomMethodWithContext(name);
-        });
+        this.notify('Type ".ls" to a view list of available context methods/properties');
     }
     /**
      * Setup context with default globals
      */
-    setupContext() {
+    #setupContext() {
         /**
          * Register "clear" method
          */
@@ -184,7 +146,7 @@ class Repl {
          * Register "p" method
          */
         this.addMethod('p', function promisify(_, fn) {
-            return (0, util_1.promisify)(fn);
+            return utilPromisify(fn);
         }, {
             description: 'Promisify a function. Similar to Node.js "util.promisify"',
             usage: `p ${this.colors.gray('(function)')}`,
@@ -192,16 +154,54 @@ class Repl {
         /**
          * Register all custom methods with the context
          */
-        this.registerCustomMethodsWithContext();
+        this.#registerCustomMethodsWithContext();
+    }
+    /**
+     * Register custom methods with the server context
+     */
+    #registerCustomMethodsWithContext() {
+        Object.keys(this.#customMethods).forEach((name) => {
+            this.#registerCustomMethodWithContext(name);
+        });
+    }
+    /**
+     * Find if the error is recoverable or not
+     */
+    #isRecoverableError(error) {
+        return /^(Unexpected end of input|Unexpected token|' expected)/.test(error.message);
+    }
+    /**
+     * Custom eval method to execute the user code
+     *
+     * Basically we are monkey patching the original eval method.
+     * The reason why we need to do that is because we want :
+     * - to compile the user code before executing it
+     * - and also benefit from the original eval method that supports
+     *  cool features like top level await.
+     */
+    #eval(code, context, filename, callback) {
+        try {
+            const compiled = this.#compiler.compile(code, filename)
+                .replace('export { };', '')
+                .replace(/\/\/# sourceMappingURL=(.*)$/, '/** sourceMappingURL=$1 */');
+            return this.#originalEval(compiled, context, filename, callback);
+        }
+        catch (error) {
+            if (this.#isRecoverableError(error)) {
+                callback(new Recoverable(error), null);
+                return;
+            }
+            callback(error, null);
+        }
     }
     /**
      * Setup history file
      */
-    setupHistory() {
-        if (!this.historyFilePath) {
+    #setupHistory() {
+        if (!this.#historyFilePath) {
             return;
         }
-        this.server.setupHistory(this.historyFilePath, (error) => {
+        this.server.setupHistory(this.#historyFilePath, (error) => {
             if (!error) {
                 return;
             }
@@ -211,66 +211,63 @@ class Repl {
         });
     }
     /**
-     * Prints the welcome message
+     * Prints the help for the context properties
      */
-    printWelcomeMessage() {
-        console.log('');
+    #printContextHelp() {
         /**
-         * Log about typescript support
-         */
-        if (this.compiler.compilesTs) {
-            console.log(`${this.colors.dim(icons.tick)} ${this.colors.dim('typescript compilation supported')}`);
-        }
-        /**
-         * Log about top level imports
+         * Print context properties
          */
-        console.log(`${this.colors.dim(icons.tick)} ${this.colors.dim('allows top level imports')}`);
         console.log('');
-        /**
-         * Log about help command
-         */
-        this.notify('Type ".ls" to a view list of available context methods/properties');
+        console.log(this.colors.green('CONTEXT PROPERTIES/METHODS:'));
+        const context = Object.keys(this.server.context).reduce((result, key) => {
+            if (!this.#customMethods[key] &&
+                !GLOBAL_NODE_PROPERTIES.includes(key) &&
+                !TS_UTILS_HELPERS.includes(key)) {
+                result[key] = this.server.context[key];
+            }
+            return result;
+        }, {});
+        console.log(inspect(context, false, 1, true));
     }
     /**
      * Prints the help for the custom methods
      */
-    printCustomMethodsHelp() {
+    #printCustomMethodsHelp() {
         /**
          * Print loader methods
          */
         console.log('');
         console.log(this.colors.green('GLOBAL METHODS:'));
-        Object.keys(this.customMethods).forEach((method) => {
-            const { options } = this.customMethods[method];
-            const spaces = new Array(this.longestCustomMethodName - options.width + 2).join(' ');
+        Object.keys(this.#customMethods).forEach((method) => {
+            const { options } = this.#customMethods[method];
+            const spaces = new Array(this.#longestCustomMethodName - options.width + 2).join(' ');
             console.log(`${this.colors.yellow(options.usage || method)}${spaces}${this.colors.dim(options.description || '')}`);
         });
     }
-    /**
-     * Prints the help for the context properties
-     */
-    printContextHelp() {
+    #registerCustomMethodWithContext(name) {
+        const customMethod = this.#customMethods[name];
+        if (!customMethod) {
+            return;
+        }
         /**
-         * Print context properties
+         * Wrap handler
          */
-        console.log('');
-        console.log(this.colors.green('CONTEXT PROPERTIES/METHODS:'));
-        const context = Object.keys(this.server?.context).reduce((result, key) => {
-            if (!this.customMethods[key] &&
-                !GLOBAL_NODE_PROPERTIES.includes(key) &&
-                !TS_UTIL_HELPERS.includes(key)) {
-                result[key] = this.server?.context[key];
-            }
-            return result;
-        }, {});
-        console.log((0, util_1.inspect)(context, false, 1, true));
+        const handler = (...args) => customMethod.handler(this, ...args);
+        /**
+         * Re-define the function name to be more description
+         */
+        Object.defineProperty(handler, 'name', { value: customMethod.handler.name });
+        /**
+         * Register with the context
+         */
+        this.server.context[name] = handler;
     }
     /**
      * Prints the context to the console
      */
-    ls() {
-        this.printCustomMethodsHelp();
-        this.printContextHelp();
+    #ls() {
+        this.#printCustomMethodsHelp();
+        this.#printContextHelp();
         this.server.displayPrompt();
     }
     /**
@@ -283,76 +280,67 @@ class Repl {
         }
     }
     /**
-     * Start the REPL session
+     * Start the REPL server
      */
     start() {
-        this.printWelcomeMessage();
-        this.server = (0, repl_1.start)({
+        this.#printWelcomeMessage();
+        this.server = startRepl({
             prompt: '> ',
             input: process.stdin,
             output: process.stdout,
-            terminal: process.stdout.isTTY && !parseInt(process.env.NODE_NO_READLINE, 10),
+            terminal: process.stdout.isTTY && !Number.parseInt(process.env.NODE_NO_READLINE, 10),
             useGlobal: true,
         });
         /**
-         * Define ls command
+         * Define the `ls` command
          */
         this.server.defineCommand('ls', {
-            help: 'View a list of available context methods/properties',
-            action: this.ls.bind(this),
+            help: 'View list of available context methods/properties',
+            action: this.#ls.bind(this),
         });
         /**
-         * Setup context
-         */
-        this.setupContext();
-        /**
-         * Setup history
+         * Setup context and history
          */
-        this.setupHistory();
+        this.#setupContext();
+        this.#setupHistory();
         /**
-         * Assigning eval function like this has better completion support.
+         * Monkey patch the eval method
          */
+        this.#originalEval = this.server.eval;
         // @ts-ignore
-        this.server['eval'] = this.eval.bind(this);
-        /**
-         * Define exports variable when using Typescript
-         */
-        if (this.compiler.compilesTs) {
-            new vm_1.Script('exports = module.exports', { filename: __dirname }).runInThisContext();
-        }
+        this.server.eval = this.#eval.bind(this);
         /**
          * Display prompt
          */
         this.server.displayPrompt();
         /**
-         * Execute onready callbacks
+         * Execute onReady callbacks
          */
-        this.onReadyCallbacks.forEach((callback) => callback(this));
+        this.#onReadyCallbacks.forEach((callback) => callback(this));
         return this;
     }
     /**
      * Register a callback to be invoked once the server is ready
      */
     ready(callback) {
-        this.onReadyCallbacks.push(callback);
+        this.#onReadyCallbacks.push(callback);
         return this;
     }
     /**
      * Register a custom loader function to be added to the context
      */
     addMethod(name, handler, options) {
-        const width = (0, string_width_1.default)(options?.usage || name);
-        if (width > this.longestCustomMethodName) {
-            this.longestCustomMethodName = width;
+        const width = stringWidth(options?.usage || name);
+        if (width > this.#longestCustomMethodName) {
+            this.#longestCustomMethodName = width;
         }
-        this.customMethods[name] = { handler, options: Object.assign({ width }, options) };
+        this.#customMethods[name] = { handler, options: Object.assign({ width }, options) };
         /**
          * Register method right away when server has been started
          */
         if (this.server) {
-            this.registerCustomMethodWithContext(name);
+            this.#registerCustomMethodWithContext(name);
         }
         return this;
     }
 }
-exports.Repl = Repl;

package/build/src/types.d.ts

@@ -0,0 +1,21 @@
+import { Repl } from './repl.js';
+/**
+ * Custom method handler
+ */
+export type Handler = (repl: Repl, ...args: any[]) => any;
+/**
+ * Options that can be set when defining a loader
+ * method
+ */
+export type ContextOptions = {
+    description?: string;
+    usage?: string;
+};
+/**
+ * Shape of the Compiler that must be passed to the
+ * repl constructor
+ */
+export type Compiler = {
+    compile: (code: string, fileName: string) => string;
+    supportsTypescript: boolean;
+};

package/build/{adonis-typings/repl.js → src/types.js}

@@ -1,8 +1,9 @@
 /*
  * @adonisjs/repl
  *
- * (c) Harminder Virk <virk@adonisjs.com>
+ * (c) AdonisJS
  *
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
+export {};