@adonisjs/assembler 8.0.0-next.4 → 8.0.0-next.6

package/build/chunk-MC3FJR62.js

@@ -0,0 +1,411 @@
+import {
+  VirtualFileSystem,
+  debug_default,
+  removeExtension,
+  throttle
+} from "./chunk-F4RAGKQN.js";
+
+// src/index_generator/source.ts
+import string from "@poppinss/utils/string";
+import { mkdir, writeFile } from "fs/promises";
+import { dirname, join, relative } from "path/posix";
+import StringBuilder from "@poppinss/utils/string_builder";
+
+// src/file_buffer.ts
+var FileBuffer = class _FileBuffer {
+  /**
+   * Collected lines
+   */
+  #buffer = [];
+  /**
+   * Current indentation size. Each call to indent will increment
+   * it by 2
+   */
+  #identationSize = 0;
+  /**
+   * Cached compiled output. Once this value is set, the `flush`
+   * method will become a noop
+   */
+  #compiledOutput;
+  /**
+   * Creates a new child buffer instance
+   *
+   * @returns A new FileBuffer instance
+   */
+  create() {
+    return new _FileBuffer();
+  }
+  /**
+   * Returns the size of buffer text
+   *
+   * @returns The number of lines in the buffer
+   */
+  get size() {
+    return this.#buffer.length;
+  }
+  /**
+   * Write a new line to the output with current indentation
+   *
+   * @param text - The text to write as a new line
+   * @returns This FileBuffer instance for method chaining
+   */
+  writeLine(text) {
+    this.#buffer.push(`${" ".repeat(this.#identationSize)}${text}
+`);
+    return this;
+  }
+  /**
+   * Write text to the output without adding a new line
+   *
+   * @param text - The text to write without a newline
+   * @returns This FileBuffer instance for method chaining
+   */
+  write(text) {
+    this.#buffer.push(`${" ".repeat(this.#identationSize)}${text}`);
+    return this;
+  }
+  /**
+   * Increase indentation by 2 spaces
+   *
+   * @returns This FileBuffer instance for method chaining
+   */
+  indent() {
+    this.#identationSize += 2;
+    return this;
+  }
+  /**
+   * Decrease indentation by 2 spaces (minimum of 0)
+   *
+   * @returns This FileBuffer instance for method chaining
+   */
+  dedent() {
+    this.#identationSize -= 2;
+    if (this.#identationSize < 0) {
+      this.#identationSize = 0;
+    }
+    return this;
+  }
+  /**
+   * Return template as a string, joining all buffer lines
+   *
+   * Once called, the output is cached and subsequent calls return the same result.
+   * The flush method becomes a no-op after the first call.
+   *
+   * @returns The complete buffer content as a string
+   */
+  flush() {
+    if (this.#compiledOutput !== void 0) {
+      return this.#compiledOutput;
+    }
+    this.#compiledOutput = this.#buffer.join("\n");
+    return this.#compiledOutput;
+  }
+};
+
+// src/index_generator/source.ts
+var IndexGeneratorSource = class {
+  /**
+   * The application root directory path
+   */
+  #appRoot;
+  /**
+   * The absolute path to the output file
+   */
+  #output;
+  /**
+   * The absolute path to the source directory
+   */
+  #source;
+  /**
+   * The directory containing the output file
+   */
+  #outputDirname;
+  /**
+   * Virtual file system for scanning source files
+   */
+  #vfs;
+  /**
+   * Configuration for this index generator source
+   */
+  #config;
+  /**
+   * CLI logger instance for output messages
+   */
+  #cliLogger;
+  /**
+   * Generate the output content and write it to the output file
+   *
+   * This method creates the file buffer, populates it with the generated
+   * content based on configuration, and writes it to disk.
+   */
+  #generateOutput = throttle(async () => {
+    const buffer = new FileBuffer();
+    if (this.#config.as === "barrelFile") {
+      this.#asBarrelFile(this.#vfs, buffer, this.#config.exportName);
+    } else {
+      this.#config.as(this.#vfs, buffer, this.#config);
+    }
+    await mkdir(dirname(this.#output), { recursive: true });
+    await writeFile(this.#output, buffer.flush());
+  });
+  /**
+   * Unique name for this index generator source
+   */
+  name;
+  /**
+   * Create a new IndexGeneratorSource instance
+   *
+   * @param name - Unique name for this index generator source
+   * @param appRoot - The application root directory path
+   * @param cliLogger - Logger instance for CLI output
+   * @param config - Configuration for this index generator source
+   */
+  constructor(name, appRoot, cliLogger, config) {
+    this.name = name;
+    this.#config = config;
+    this.#appRoot = appRoot;
+    this.#cliLogger = cliLogger;
+    this.#source = join(this.#appRoot, this.#config.source);
+    this.#output = join(this.#appRoot, this.#config.output);
+    this.#outputDirname = dirname(this.#output);
+    this.#vfs = new VirtualFileSystem(this.#source, {
+      glob: this.#config.glob
+    });
+  }
+  /**
+   * Set the logger instance used for CLI output
+   *
+   * @param cliLogger - New logger instance to use
+   */
+  setLogger(cliLogger) {
+    this.#cliLogger = cliLogger;
+  }
+  /**
+   * Converts a recursive file tree to a string representation
+   *
+   * This method recursively processes a file tree structure and writes
+   * it as JavaScript object notation to the provided buffer.
+   *
+   * @param input - The recursive file tree to convert
+   * @param buffer - The file buffer to write the output to
+   */
+  #treeToString(input, buffer) {
+    Object.keys(input).forEach((key) => {
+      const value = input[key];
+      if (typeof value === "string") {
+        buffer.write(`'${key}': ${value},`);
+      } else {
+        buffer.write(`'${key}': {`).indent();
+        this.#treeToString(value, buffer);
+        buffer.dedent().write(`},`);
+      }
+    });
+  }
+  /**
+   * Transforms the barrel file index key. Converts basename to PascalCase
+   * and all other paths to camelCase
+   *
+   * @param config - Configuration containing suffix removal options
+   * @returns Function that transforms file paths to appropriate keys
+   */
+  #createBarrelFileKeyGenerator(config) {
+    return function(key) {
+      const paths = key.split("/");
+      const baseName = new StringBuilder(paths.pop()).removeSuffix(config.removeSuffix ?? "").pascalCase().toString();
+      return [...paths.map((p) => string.camelCase(p)), baseName].join("/");
+    };
+  }
+  /**
+   * Converts the file path to a lazy import. In case of an alias, the source
+   * path is replaced with the alias, otherwise a relative import is created
+   * from the output dirname.
+   *
+   * @param source - The source directory path
+   * @param outputDirname - The output directory path
+   * @param config - Configuration containing import alias options
+   * @returns Function that converts file paths to import statements
+   */
+  #createBarrelFileImportGenerator(source, outputDirname, config) {
+    return function(filePath) {
+      if (config.importAlias) {
+        debug_default('converting "%s" to import alias, source "%s"', filePath, source);
+        return `() => import('${removeExtension(filePath.replace(source, config.importAlias))}')`;
+      }
+      debug_default('converting "%s" to relative import, source "%s"', filePath, outputDirname);
+      return `() => import('${relative(outputDirname, filePath)}')`;
+    };
+  }
+  /**
+   * Generate a barrel file export structure
+   *
+   * This method creates a nested object structure that represents all
+   * discovered files as lazy imports, organized by directory structure.
+   *
+   * @param vfs - Virtual file system containing the scanned files
+   * @param buffer - File buffer to write the barrel exports to
+   * @param exportName - Name for the main export object
+   */
+  #asBarrelFile(vfs, buffer, exportName) {
+    const keyGenerator = this.#createBarrelFileKeyGenerator(this.#config);
+    const importGenerator = this.#createBarrelFileImportGenerator(
+      this.#source,
+      this.#outputDirname,
+      this.#config
+    );
+    const tree = vfs.asTree({
+      transformKey: keyGenerator,
+      transformValue: importGenerator
+    });
+    buffer.write(`export const ${exportName} = {`).indent();
+    this.#treeToString(tree, buffer);
+    buffer.dedent().write(`}`);
+  }
+  /**
+   * Create a log action for tracking file generation progress
+   *
+   * @example
+   * const action = this.#createLogAction()
+   * // ... perform operations
+   * action.displayDuration().succeeded()
+   */
+  #createLogAction() {
+    return this.#cliLogger.action(`create ${this.#config.output}`);
+  }
+  /**
+   * Add a file to the virtual file system and regenerate index if needed
+   *
+   * If the file matches the configured glob patterns, it will be added
+   * to the virtual file system and the index file will be regenerated.
+   *
+   * @param filePath - Absolute path of the file to add
+   */
+  async addFile(filePath) {
+    const added = this.#vfs.add(filePath);
+    if (added) {
+      debug_default('file added, re-generating "%s" index', this.name);
+      const action = this.#createLogAction();
+      await this.#generateOutput();
+      action.displayDuration().succeeded();
+    }
+  }
+  /**
+   * Remove a file from the virtual file system and regenerate index if needed
+   *
+   * If the file was previously tracked, it will be removed from the
+   * virtual file system and the index file will be regenerated.
+   *
+   * @param filePath - Absolute path of the file to remove
+   */
+  async removeFile(filePath) {
+    const removed = this.#vfs.remove(filePath);
+    if (removed) {
+      debug_default('file removed, re-generating "%s" index', this.name);
+      const action = this.#createLogAction();
+      await this.#generateOutput();
+      action.displayDuration().succeeded();
+    }
+  }
+  /**
+   * Generate the index file
+   *
+   * This method scans the source directory, processes files according to
+   * the configuration, and writes the generated index file to disk.
+   */
+  async generate() {
+    const action = this.#createLogAction();
+    await this.#vfs.scan();
+    await this.#generateOutput();
+    action.displayDuration().succeeded();
+  }
+};
+
+// src/index_generator/main.ts
+var IndexGenerator = class {
+  /**
+   * The application root directory path
+   */
+  #appRoot;
+  /**
+   * Collection of registered index generator sources
+   */
+  #sources = {};
+  #cliLogger;
+  /**
+   * Create a new IndexGenerator instance
+   *
+   * @param appRoot - The application root directory path
+   * @param cliLogger - Logger instance for CLI output
+   */
+  constructor(appRoot, cliLogger) {
+    this.#appRoot = appRoot;
+    this.#cliLogger = cliLogger;
+  }
+  /**
+   * Set the logger instance used for CLI output
+   *
+   * Updates the CLI logger instance for this index generator and all
+   * registered sources to use the new logger for output.
+   *
+   * @param cliLogger - New logger instance to use
+   */
+  setLogger(cliLogger) {
+    this.#cliLogger = cliLogger;
+  }
+  /**
+   * Add a new index generator source
+   *
+   * @param name - Unique name for the source
+   * @param config - Configuration for the index generator source
+   * @returns This IndexGenerator instance for method chaining
+   */
+  add(name, config) {
+    this.#sources[name] = new IndexGeneratorSource(name, this.#appRoot, this.#cliLogger, config);
+    return this;
+  }
+  /**
+   * Add a file to all registered index generator sources
+   *
+   * This method propagates the file addition to all registered sources,
+   * allowing them to regenerate their index files if the new file matches
+   * their glob patterns.
+   *
+   * @param filePath - Absolute path of the file to add
+   */
+  async addFile(filePath) {
+    const sources = Object.values(this.#sources);
+    for (let source of sources) {
+      await source.addFile(filePath);
+    }
+  }
+  /**
+   * Remove a file from all registered index generator sources
+   *
+   * This method propagates the file removal to all registered sources,
+   * allowing them to regenerate their index files if the removed file
+   * was previously tracked.
+   *
+   * @param filePath - Absolute path of the file to remove
+   */
+  async removeFile(filePath) {
+    const sources = Object.values(this.#sources);
+    for (let source of sources) {
+      await source.removeFile(filePath);
+    }
+  }
+  /**
+   * Generate all registered index files
+   *
+   * Iterates through all registered sources and generates their
+   * corresponding index files.
+   */
+  async generate() {
+    const sources = Object.values(this.#sources);
+    for (let source of sources) {
+      await source.generate();
+    }
+  }
+};
+
+export {
+  IndexGenerator
+};

package/build/chunk-TIKQQRMX.js

@@ -0,0 +1,116 @@
+// src/helpers.ts
+import { parseImports } from "parse-imports";
+async function findImport(code, importReference) {
+  const importIdentifier = importReference.split(".")[0];
+  for (const $import of await parseImports(code, {})) {
+    if (!$import.importClause) {
+      continue;
+    }
+    if (!$import.moduleSpecifier.value) {
+      continue;
+    }
+    if ($import.importClause.default === importIdentifier) {
+      return {
+        specifier: $import.moduleSpecifier.value,
+        isConstant: $import.moduleSpecifier.isConstant,
+        clause: {
+          type: "default",
+          value: importIdentifier
+        }
+      };
+    }
+    if ($import.importClause.namespace === importIdentifier) {
+      return {
+        specifier: $import.moduleSpecifier.value,
+        isConstant: $import.moduleSpecifier.isConstant,
+        clause: {
+          type: "namespace",
+          value: importIdentifier
+        }
+      };
+    }
+    const namedImport = $import.importClause.named.find(({ binding }) => {
+      return binding === importIdentifier;
+    });
+    if (namedImport) {
+      return {
+        specifier: $import.moduleSpecifier.value,
+        isConstant: $import.moduleSpecifier.isConstant,
+        clause: {
+          type: "named",
+          value: namedImport.specifier,
+          ...namedImport.binding !== namedImport.specifier ? {
+            alias: namedImport.binding
+          } : {}
+        }
+      };
+    }
+  }
+  return null;
+}
+function inspectClass(node) {
+  return node.find({
+    rule: {
+      kind: "class_declaration"
+    }
+  });
+}
+function inspectClassMethods(node) {
+  return node.findAll({
+    rule: {
+      kind: "method_definition"
+    }
+  });
+}
+function nodeToPlainText(node) {
+  let out = [];
+  function toText(one) {
+    const children = one.children();
+    if (!children.length) {
+      out.push(one.text());
+    } else {
+      children.forEach((child) => toText(child));
+    }
+  }
+  toText(node);
+  return out.join("");
+}
+function inspectMethodArguments(node, methodCalls) {
+  const matchingExpressions = node.findAll({
+    rule: {
+      any: methodCalls.map((methodCall) => {
+        return {
+          pattern: {
+            context: `${methodCall}($$$ARGUMENTS)`,
+            selector: "call_expression"
+          }
+        };
+      })
+    }
+  });
+  return matchingExpressions.flatMap((matchingExpression) => {
+    return matchingExpression.findAll({ rule: { kind: "arguments" } });
+  });
+}
+function searchValidatorDirectUsage(node) {
+  const matchingExpressions = node.findAll({
+    rule: {
+      pattern: {
+        context: "$$$VALIDATOR.validate($$$)",
+        selector: "call_expression"
+      }
+    }
+  });
+  return matchingExpressions.flatMap((expression) => {
+    return expression.getMultipleMatches("VALIDATOR");
+  });
+}
+
+export {
+  findImport,
+  inspectClass,
+  inspectClassMethods,
+  nodeToPlainText,
+  inspectMethodArguments,
+  searchValidatorDirectUsage
+};

package/build/index.d.ts

@@ -1,3 +1,4 @@
 export { Bundler } from './src/bundler.ts';
 export { DevServer } from './src/dev_server.ts';
 export { TestRunner } from './src/test_runner.ts';
+export { SUPPORTED_PACKAGE_MANAGERS } from './src/bundler.ts';