@reliverse/dler 1.7.24 → 1.7.25

package/bin/libs/sdk/sdk-impl/cmds/transform/transform-impl-mod.d.ts

@@ -0,0 +1,117 @@
+import type { SourceMapOptions } from "magic-string";
+import MagicString from "magic-string";
+export interface MagicStringOptions {
+    filename?: string;
+    indentExclusionRanges?: [number, number][];
+    ignoreList?: boolean;
+    offset?: number;
+}
+export interface UpdateOptions {
+    storeName?: boolean;
+    overwrite?: boolean;
+}
+export interface OverwriteOptions {
+    storeName?: boolean;
+    contentOnly?: boolean;
+}
+export interface IndentOptions {
+    exclude?: [number, number][];
+}
+export interface StringTransformer {
+    readonly original: string;
+    readonly current: () => string;
+    readonly hasChanged: () => boolean;
+    readonly isEmpty: () => boolean;
+    readonly clone: () => StringTransformer;
+    readonly generateMap: (options?: SourceMapOptions) => any;
+    readonly generateDecodedMap: (options?: SourceMapOptions) => any;
+}
+export interface TransformResult {
+    code: string;
+    map?: any;
+    hasChanged: boolean;
+    transformer: StringTransformer;
+}
+export declare const createTransformerFromMagicString: (ms: MagicString, original: string) => StringTransformer;
+export declare const createTransformer: (source: string, options?: MagicStringOptions) => StringTransformer;
+export declare const update: (transformer: StringTransformer, start: number, end: number, content: string, options?: UpdateOptions) => StringTransformer;
+export declare const overwrite: (transformer: StringTransformer, start: number, end: number, content: string, options?: OverwriteOptions) => StringTransformer;
+export declare const append: (transformer: StringTransformer, content: string) => StringTransformer;
+export declare const prepend: (transformer: StringTransformer, content: string) => StringTransformer;
+export declare const remove: (transformer: StringTransformer, start: number, end: number) => StringTransformer;
+export declare const replace: (transformer: StringTransformer, searchValue: string | RegExp, replaceValue: string | ((match: string, ...args: any[]) => string)) => StringTransformer;
+export declare const replaceAll: (transformer: StringTransformer, searchValue: string | RegExp, replaceValue: string | ((match: string, ...args: any[]) => string)) => StringTransformer;
+export declare const indent: (transformer: StringTransformer, prefix?: string, options?: IndentOptions) => StringTransformer;
+export declare const trim: (transformer: StringTransformer, charType?: string) => StringTransformer;
+export declare const pipe: <T>(value: T, ...operations: ((input: T) => T)[]) => T;
+export declare const wrapWith: (transformer: StringTransformer, prefix: string, suffix: string) => StringTransformer;
+export declare const insertAt: (transformer: StringTransformer, index: number, content: string) => StringTransformer;
+export declare const slice: (transformer: StringTransformer, start?: number, end?: number) => string;
+export declare const template: (strings: TemplateStringsArray, ...values: any[]) => StringTransformer;
+export declare const readAndTransform: (filePath: string, transformer: (content: StringTransformer) => StringTransformer) => Promise<TransformResult>;
+export declare const transformAndWrite: (inputPath: string, outputPath: string, transformer: (content: StringTransformer) => StringTransformer, options?: {
+    generateSourceMap?: boolean;
+    sourceMapPath?: string;
+}) => Promise<void>;
+export declare const transformMultiple: (transformations: {
+    input: string;
+    output: string;
+    transformer: (content: StringTransformer) => StringTransformer;
+}[]) => Promise<void>;
+export interface BundleSource {
+    filename: string;
+    content: StringTransformer;
+    ignoreList?: boolean;
+    indentExclusionRanges?: [number, number][];
+}
+export declare const createBundle: (sources?: BundleSource[]) => {
+    addSource: (source: BundleSource) => /*elided*/ any;
+    indent: (prefix?: string) => /*elided*/ any;
+    prepend: (content: string) => /*elided*/ any;
+    append: (content: string) => /*elided*/ any;
+    toString: () => string;
+    generateMap: (options?: SourceMapOptions) => Omit<import("magic-string").SourceMap, "sourcesContent"> & {
+        sourcesContent: Array<string | null>;
+    };
+};
+export declare const compose: <T>(...transformers: ((input: T) => T)[]) => ((input: T) => T);
+export * from "magic-string";
+declare const _default: {
+    createTransformer: (source: string, options?: MagicStringOptions) => StringTransformer;
+    update: (transformer: StringTransformer, start: number, end: number, content: string, options?: UpdateOptions) => StringTransformer;
+    overwrite: (transformer: StringTransformer, start: number, end: number, content: string, options?: OverwriteOptions) => StringTransformer;
+    append: (transformer: StringTransformer, content: string) => StringTransformer;
+    prepend: (transformer: StringTransformer, content: string) => StringTransformer;
+    remove: (transformer: StringTransformer, start: number, end: number) => StringTransformer;
+    replace: (transformer: StringTransformer, searchValue: string | RegExp, replaceValue: string | ((match: string, ...args: any[]) => string)) => StringTransformer;
+    replaceAll: (transformer: StringTransformer, searchValue: string | RegExp, replaceValue: string | ((match: string, ...args: any[]) => string)) => StringTransformer;
+    indent: (transformer: StringTransformer, prefix?: string, options?: IndentOptions) => StringTransformer;
+    trim: (transformer: StringTransformer, charType?: string) => StringTransformer;
+    pipe: <T>(value: T, ...operations: ((input: T) => T)[]) => T;
+    wrapWith: (transformer: StringTransformer, prefix: string, suffix: string) => StringTransformer;
+    insertAt: (transformer: StringTransformer, index: number, content: string) => StringTransformer;
+    slice: (transformer: StringTransformer, start?: number, end?: number) => string;
+    template: (strings: TemplateStringsArray, ...values: any[]) => StringTransformer;
+    readAndTransform: (filePath: string, transformer: (content: StringTransformer) => StringTransformer) => Promise<TransformResult>;
+    transformAndWrite: (inputPath: string, outputPath: string, transformer: (content: StringTransformer) => StringTransformer, options?: {
+        generateSourceMap?: boolean;
+        sourceMapPath?: string;
+    }) => Promise<void>;
+    transformMultiple: (transformations: {
+        input: string;
+        output: string;
+        transformer: (content: StringTransformer) => StringTransformer;
+    }[]) => Promise<void>;
+    createBundle: (sources?: BundleSource[]) => {
+        addSource: (source: BundleSource) => /*elided*/ any;
+        indent: (prefix?: string) => /*elided*/ any;
+        prepend: (content: string) => /*elided*/ any;
+        append: (content: string) => /*elided*/ any;
+        toString: () => string;
+        generateMap: (options?: SourceMapOptions) => Omit<import("magic-string").SourceMap, "sourcesContent"> & {
+            sourcesContent: Array<string | null>;
+        };
+    };
+    compose: <T>(...transformers: ((input: T) => T)[]) => ((input: T) => T);
+};
+export default _default;

package/bin/libs/sdk/sdk-impl/cmds/transform/transform-impl-mod.js

@@ -0,0 +1,178 @@
+import MagicString, { Bundle } from "magic-string";
+import { promises as fs } from "node:fs";
+export const createTransformerFromMagicString = (ms, original) => {
+  const transformer = {
+    original,
+    _ms: ms,
+    current: () => ms.toString(),
+    hasChanged: () => ms.hasChanged(),
+    isEmpty: () => ms.isEmpty(),
+    clone: () => createTransformerFromMagicString(ms.clone(), original),
+    generateMap: (mapOptions) => ms.generateMap(mapOptions),
+    generateDecodedMap: (mapOptions) => ms.generateDecodedMap(mapOptions)
+  };
+  return transformer;
+};
+export const createTransformer = (source, options) => {
+  const ms = new MagicString(source, options);
+  return createTransformerFromMagicString(ms, source);
+};
+export const update = (transformer, start, end, content, options) => {
+  const ms = transformer._ms.clone();
+  ms.update(start, end, content, options);
+  return createTransformerFromMagicString(ms, transformer.original);
+};
+export const overwrite = (transformer, start, end, content, options) => {
+  const ms = transformer._ms.clone();
+  ms.overwrite(start, end, content, options);
+  return createTransformerFromMagicString(ms, transformer.original);
+};
+export const append = (transformer, content) => {
+  const ms = transformer._ms.clone();
+  ms.append(content);
+  return createTransformerFromMagicString(ms, transformer.original);
+};
+export const prepend = (transformer, content) => {
+  const ms = transformer._ms.clone();
+  ms.prepend(content);
+  return createTransformerFromMagicString(ms, transformer.original);
+};
+export const remove = (transformer, start, end) => {
+  const ms = transformer._ms.clone();
+  ms.remove(start, end);
+  return createTransformerFromMagicString(ms, transformer.original);
+};
+export const replace = (transformer, searchValue, replaceValue) => {
+  const ms = transformer._ms.clone();
+  ms.replace(searchValue, replaceValue);
+  return createTransformerFromMagicString(ms, transformer.original);
+};
+export const replaceAll = (transformer, searchValue, replaceValue) => {
+  const ms = transformer._ms.clone();
+  ms.replaceAll(searchValue, replaceValue);
+  return createTransformerFromMagicString(ms, transformer.original);
+};
+export const indent = (transformer, prefix, options) => {
+  const ms = transformer._ms.clone();
+  ms.indent(prefix, options);
+  return createTransformerFromMagicString(ms, transformer.original);
+};
+export const trim = (transformer, charType) => {
+  const ms = transformer._ms.clone();
+  ms.trim(charType);
+  return createTransformerFromMagicString(ms, transformer.original);
+};
+export const pipe = (value, ...operations) => {
+  return operations.reduce((acc, operation) => operation(acc), value);
+};
+export const wrapWith = (transformer, prefix, suffix) => {
+  return pipe(
+    transformer,
+    (t) => prepend(t, prefix),
+    (t) => append(t, suffix)
+  );
+};
+export const insertAt = (transformer, index, content) => {
+  const ms = transformer._ms.clone();
+  ms.appendLeft(index, content);
+  return createTransformerFromMagicString(ms, transformer.original);
+};
+export const slice = (transformer, start = 0, end) => {
+  const currentString = transformer.current();
+  return currentString.slice(start, end ?? currentString.length);
+};
+export const template = (strings, ...values) => {
+  const source = strings.reduce((result, string, i) => result + string + (values[i] || ""), "");
+  return createTransformer(source);
+};
+export const readAndTransform = async (filePath, transformer) => {
+  const content = await fs.readFile(filePath, "utf-8");
+  const original = createTransformer(content);
+  const transformed = transformer(original);
+  return {
+    code: transformed.current(),
+    hasChanged: transformed.hasChanged(),
+    transformer: transformed
+  };
+};
+export const transformAndWrite = async (inputPath, outputPath, transformer, options) => {
+  const result = await readAndTransform(inputPath, transformer);
+  await fs.writeFile(outputPath, result.code);
+  if (options?.generateSourceMap && options.sourceMapPath) {
+    const map = result.transformer.generateMap({
+      source: inputPath,
+      file: options.sourceMapPath,
+      includeContent: true
+    });
+    await fs.writeFile(options.sourceMapPath, map.toString());
+  }
+};
+export const transformMultiple = async (transformations) => {
+  await Promise.all(
+    transformations.map(
+      ({ input, output, transformer }) => transformAndWrite(input, output, transformer)
+    )
+  );
+};
+export const createBundle = (sources = []) => {
+  const bundle = new Bundle();
+  for (const source of sources) {
+    bundle.addSource({
+      filename: source.filename,
+      content: new MagicString(source.content.current()),
+      ignoreList: source.ignoreList,
+      indentExclusionRanges: source.indentExclusionRanges
+    });
+  }
+  return {
+    addSource: (source) => {
+      bundle.addSource({
+        filename: source.filename,
+        content: new MagicString(source.content.current()),
+        ignoreList: source.ignoreList,
+        indentExclusionRanges: source.indentExclusionRanges
+      });
+      return createBundle([]);
+    },
+    indent: (prefix) => {
+      bundle.indent(prefix);
+      return createBundle([]);
+    },
+    prepend: (content) => {
+      bundle.prepend(content);
+      return createBundle([]);
+    },
+    append: (content) => {
+      bundle.append(content);
+      return createBundle([]);
+    },
+    toString: () => bundle.toString(),
+    generateMap: (options) => bundle.generateMap(options)
+  };
+};
+export const compose = (...transformers) => {
+  return (input) => transformers.reduceRight((acc, transformer) => transformer(acc), input);
+};
+export * from "magic-string";
+export default {
+  createTransformer,
+  update,
+  overwrite,
+  append,
+  prepend,
+  remove,
+  replace,
+  replaceAll,
+  indent,
+  trim,
+  pipe,
+  wrapWith,
+  insertAt,
+  slice,
+  template,
+  readAndTransform,
+  transformAndWrite,
+  transformMultiple,
+  createBundle,
+  compose
+};

package/bin/libs/sdk/sdk-impl/config/info.js

@@ -1,5 +1,5 @@
 import { endPrompt, startPrompt } from "@reliverse/rempts";
-const version = "1.7.24";
+const version = "1.7.25";
 export async function showStartPrompt(isDev) {
   await startPrompt({
     titleColor: "inverse",

package/bin/libs/sdk/sdk-impl/magic/{apply.d.ts → ms-apply.d.ts}

@@ -35,6 +35,7 @@ export interface ApplyMagicSpellsResult {
  * @returns Object containing arrays of processed files and processed .d.ts files
  */
 export declare function applyMagicSpells(targets: string[], options?: Partial<ApplyMagicSpellsOptions>): Promise<ApplyMagicSpellsResult>;
+export declare function processSingleOutputFile(filePath: string, options?: Partial<ApplyMagicSpellsOptions>): Promise<boolean>;
 /**
  * Gets all available registries across all libraries
  * @returns Array of unique registry names found across all libraries

package/bin/libs/sdk/sdk-impl/magic/{apply.js → ms-apply.js}

@@ -4,7 +4,9 @@ import { relinka } from "@reliverse/relinka";
 import pMap from "p-map";
 import { isBinaryExt } from "../utils/binary.js";
 import { formatError } from "../utils/utils-error-cwd.js";
-import { evaluateMagicDirective } from "./spells.js";
+import {
+  evaluateMagicDirective
+} from "./ms-spells.js";
 const DEBUG_MODE = true;
 const PROCESS_DTS_FILES = true;
 const DEFAULT_OPTIONS = {
@@ -29,7 +31,7 @@ function validateTargets(targets, customOutputPaths) {
       throw new Error(`Invalid output target: ${target}`);
     }
     const outputPath = allOutputPaths[outputDir] || outputDir;
-    const fullPath = path.join(process.cwd(), outputPath);
+    const fullPath = path.isAbsolute(outputPath) ? outputPath : path.join(process.cwd(), outputPath);
     if (!fs.existsSync(fullPath)) {
       throw new Error(`Output directory does not exist: ${outputPath}`);
     }
@@ -149,7 +151,7 @@ async function processCustomTarget(outputDir, options = {}) {
   }
   const outputFilesToProcess = [];
   const outputPath = options.customOutputPaths?.[outputDir] || outputDir;
-  const fullOutputPath = path.join(process.cwd(), outputPath);
+  const fullOutputPath = path.isAbsolute(outputPath) ? outputPath : path.join(process.cwd(), outputPath);
   for await (const filePath of walkDirectoryTree(fullOutputPath)) {
     if (await isBinaryExt(filePath)) {
       continue;
@@ -340,7 +342,7 @@ async function findSourceFile(distFilePath) {
   }
   return null;
 }
-async function processSingleOutputFile(filePath, options = {}) {
+export async function processSingleOutputFile(filePath, options = {}) {
   const projectRel = path.relative(process.cwd(), filePath).replaceAll(path.sep, "/");
   if (await isBinaryExt(filePath)) {
     if (DEBUG_MODE) relinka("log", `[spells] \u2298 binary  ${projectRel}`);
@@ -349,7 +351,7 @@ async function processSingleOutputFile(filePath, options = {}) {
   let copiedFromSource = false;
   if (options.copyFileWithDirectivesFromSrcBeforeProcessing ?? DEFAULT_OPTIONS.copyFileWithDirectivesFromSrcBeforeProcessing) {
     const sourceFile = await findSourceFile(filePath);
-    if (sourceFile) {
+    if (sourceFile && sourceFile !== filePath) {
       try {
         await fs.copyFile(sourceFile, filePath);
         copiedFromSource = true;
@@ -364,15 +366,17 @@ async function processSingleOutputFile(filePath, options = {}) {
     const source = await fs.readFile(filePath, "utf8");
     const ctx = { filePath: projectRel };
     let removeFile = false;
+    const allLines = source.split(/\r?\n/);
     const processedLines = [];
-    for (const line of source.split(/\r?\n/)) {
+    for (let i = allLines.length - 1; i >= 0; i--) {
+      const line = allLines[i];
       const outcome = evaluateMagicDirective(line, ctx);
       if (outcome.removeFile) {
         removeFile = true;
         break;
       }
       if (!outcome.removeLine) {
-        processedLines.push(outcome.replacement ?? line);
+        processedLines.unshift(outcome.replacement ?? line);
       }
     }
     if (removeFile) {
@@ -411,7 +415,7 @@ async function findOutputFiles(sourceFilePath, outputDir, libName, customOutputP
         extensions = [ext];
       }
       for (const outputExt of extensions) {
-        const outputFile = path.join(process.cwd(), outputPath, `${baseName}${outputExt}`);
+        const outputFile = path.isAbsolute(outputPath) ? path.join(outputPath, `${baseName}${outputExt}`) : path.join(process.cwd(), outputPath, `${baseName}${outputExt}`);
         if (await fs.pathExists(outputFile)) {
           outputFiles.push(outputFile);
         }
@@ -429,7 +433,7 @@ async function findOutputFiles(sourceFilePath, outputDir, libName, customOutputP
       extensions = [ext];
     }
     for (const outputExt of extensions) {
-      const outputFile = path.join(process.cwd(), outputPath, `${baseName}${outputExt}`);
+      const outputFile = path.isAbsolute(basePath) ? path.join(basePath, dirPath === "." ? "" : dirPath, `${baseName}${outputExt}`) : path.join(process.cwd(), outputPath, `${baseName}${outputExt}`);
       if (await fs.pathExists(outputFile)) {
         outputFiles.push(outputFile);
       }
@@ -483,6 +487,10 @@ async function getSpellImplementationPaths() {
   return paths;
 }
 async function isSpellImplementationFile(projectRelPath) {
+  const fileName = path.basename(projectRelPath);
+  if (fileName === "ms-apply.ts" || fileName === "ms-apply.js" || fileName === "ms-apply.d.ts" || fileName === "ms-spells.ts" || fileName === "ms-spells.js" || fileName === "ms-spells.d.ts") {
+    return true;
+  }
   const spellPaths = await getSpellImplementationPaths();
   return spellPaths.some((spellPath) => projectRelPath.includes(spellPath));
 }
@@ -573,7 +581,7 @@ export async function getFilesWithMagicSpells(dirs, options = {}) {
     await pMap(
       dirs,
       async (dir) => {
-        const fullPath = path.join(process.cwd(), dir);
+        const fullPath = path.isAbsolute(dir) ? dir : path.join(process.cwd(), dir);
         if (!await fs.pathExists(fullPath)) {
           const error = `Directory does not exist: ${dir}`;
           if (stopOnError) {

package/bin/libs/sdk/sdk-impl/magic/{spells.d.ts → ms-spells.d.ts}

@@ -24,7 +24,7 @@ export interface SpellOutcome {
     removeLine: boolean;
     removeFile: boolean;
 }
-export type SpellDirective = "dler-replace-line-to" | "dler-remove-line" | "dler-remove-file" | "dler-remove-comment";
+export type SpellDirective = "dler-replace-line-to" | "dler-remove-line" | "dler-remove-file" | "dler-remove-comment" | "dler-ignore-this-line";
 export interface SpellInfo {
     /** The name of the spell directive */
     name: SpellDirective;

package/bin/libs/sdk/sdk-impl/magic/{spells.js → ms-spells.js}

@@ -10,7 +10,7 @@ export function getAvailableSpells() {
       name: "dler-replace-line-to",
       description: "Replaces the current line with new content, optionally based on a condition",
       example: "// <dler-replace-line-to `export const version = \"1.0.0\";` if 'current file path starts with dist-npm'>",
-      notes: "If condition is not met and else content is provided, uses else content. Otherwise keeps original line. Also supports @ts-expect-error prefix."
+      notes: "If no condition is specified, replacement always applies. If condition is not met and else content is provided, uses else content. Otherwise keeps original line. Also supports @ts-expect-error prefix."
     },
     {
       name: "dler-remove-line",
@@ -26,13 +26,22 @@ export function getAvailableSpells() {
     },
     {
       name: "dler-remove-comment",
-      description: "Removes the current line if it's a comment",
-      example: "// <dler-remove-comment>",
-      notes: "Only removes the line if it starts with //. Useful for cleaning up comments in output files. Also supports @ts-expect-error prefix."
+      description: "Removes only the comment portion containing this directive from the line",
+      example: "console.log('debug info'); // <dler-remove-comment>",
+      notes: "Removes everything from '//' to the end of the line when the comment contains this directive. The code portion before the comment is preserved. Also supports @ts-expect-error prefix."
+    },
+    {
+      name: "dler-ignore-this-line",
+      description: "Prevents any magic directives on this line from being processed",
+      example: "// <dler-remove-line> // <dler-ignore-this-line>",
+      notes: "When present on a line, all magic directives on that line are ignored and the line is kept as-is. Useful for code that contains magic directive strings that shouldn't be executed."
     }
   ];
 }
 export function evaluateMagicDirective(line, ctx) {
+  if (line.includes("<dler-ignore-this-line>")) {
+    return NO_OP;
+  }
   const match = line.match(SPELL_REGEX);
   if (!match) return NO_OP;
   const [, directive = "", body] = match;
@@ -57,8 +66,12 @@ export function evaluateMagicDirective(line, ctx) {
     /* dler-remove-comment                                            */
     /* -------------------------------------------------------------- */
     case "dler-remove-comment": {
-      const isComment = line.trim().startsWith("//");
-      return { removeLine: isComment, removeFile: false };
+      const commentIndex = line.indexOf("//");
+      if (commentIndex !== -1) {
+        const codeBeforeComment = line.substring(0, commentIndex).trimEnd();
+        return { replacement: codeBeforeComment, removeLine: false, removeFile: false };
+      }
+      return NO_OP;
     }
     /* -------------------------------------------------------------- */
     /* dler-replace-line-to                                           */
@@ -78,6 +91,12 @@ export function evaluateMagicDirective(line, ctx) {
       }
       return NO_OP;
     }
+    /* -------------------------------------------------------------- */
+    /* dler-ignore-this-line                                          */
+    /* -------------------------------------------------------------- */
+    case "dler-ignore-this-line": {
+      return NO_OP;
+    }
     default:
       return NO_OP;
   }
@@ -88,7 +107,8 @@ function isValidMagicDirective(directive) {
     "dler-replace-line-to",
     "dler-remove-line",
     "dler-remove-file",
-    "dler-remove-comment"
+    "dler-remove-comment",
+    "dler-ignore-this-line"
   ].includes(directive);
 }
 function parseReplacementDirective(body) {
@@ -100,8 +120,6 @@ function parseReplacementDirective(body) {
   const ifMatch = body.match(IF_CONDITION_REGEX);
   if (ifMatch?.[1]) {
     parts.condition = ifMatch[1].trim();
-  } else {
-    parts.condition = "current file path starts with dist-jsr or dist-npm";
   }
   const elseMatch = body.match(ELSE_CONTENT_REGEX);
   if (elseMatch?.[1]) parts.elseContent = elseMatch[1].trim();

package/bin/libs/sdk/sdk-impl/rules/reliverse/no-dynamic-imports/no-dynamic-imports.d.ts

@@ -0,0 +1,2 @@
+import type { CheckResult } from "../../../../sdk-types.js";
+export declare function checkNoDynamicImports(directory: string): Promise<CheckResult>;

package/bin/libs/sdk/sdk-impl/rules/reliverse/no-dynamic-imports/no-dynamic-imports.js

@@ -0,0 +1,41 @@
+import path from "@reliverse/pathkit";
+import { promises as fs } from "node:fs";
+import { glob } from "tinyglobby";
+export async function checkNoDynamicImports(directory) {
+  const startTime = Date.now();
+  const issues = [];
+  const files = await glob("**/*.{ts,tsx,js,jsx}", {
+    cwd: directory,
+    ignore: ["**/node_modules/**", "**/dist/**"]
+  });
+  for (const file of files) {
+    const filePath = path.join(directory, file);
+    const content = await fs.readFile(filePath, "utf-8");
+    const lines = content.split("\n");
+    const dynamicImportRegex = /await\s+import\s*\(/g;
+    let match;
+    while (true) {
+      match = dynamicImportRegex.exec(content);
+      if (!match) break;
+      const lineNumber = content.substring(0, match.index).split("\n").length;
+      const lineContent = lines[lineNumber - 1] ?? "";
+      const column = match.index - content.lastIndexOf("\n", match.index);
+      issues.push({
+        type: "file-extension",
+        file,
+        line: lineNumber,
+        column,
+        message: `Dynamic import found: ${lineContent.trim()}. Consider using static imports for better tree-shaking, type inference, and performance.`
+      });
+    }
+  }
+  return {
+    success: issues.length === 0,
+    issues,
+    stats: {
+      filesChecked: files.length,
+      importsChecked: 0,
+      timeElapsed: Date.now() - startTime
+    }
+  };
+}

package/bin/libs/sdk/sdk-mod.d.ts

@@ -59,10 +59,10 @@ export type { AllowedFileExtensionsType } from "./sdk-impl/rules/rules-consts.js
 export { ALLOWED_FILE_EXTENSIONS, STRICT_FILE_EXTENSIONS, ALLOWED_IMPORT_EXTENSIONS, STRICT_IMPORT_EXTENSIONS, } from "./sdk-impl/rules/rules-consts.js";
 export { displayCheckResults } from "./sdk-impl/rules/rules-mod.js";
 export { shouldIgnoreFile, getAllFiles, getLineNumber } from "./sdk-impl/rules/rules-utils.js";
-export type { ApplyMagicSpellsOptions, ApplyMagicSpellsResult, } from "./sdk-impl/magic/apply.js";
-export { applyMagicSpells, getAllAvailableRegistries } from "./sdk-impl/magic/apply.js";
-export type { SpellEvaluationContext, SpellOutcome, SpellDirective, } from "./sdk-impl/magic/spells.js";
-export { evaluateMagicDirective } from "./sdk-impl/magic/spells.js";
+export type { ApplyMagicSpellsOptions, ApplyMagicSpellsResult, } from "./sdk-impl/magic/ms-apply.js";
+export { applyMagicSpells, getAllAvailableRegistries } from "./sdk-impl/magic/ms-apply.js";
+export type { SpellEvaluationContext, SpellOutcome, SpellDirective, } from "./sdk-impl/magic/ms-spells.js";
+export { evaluateMagicDirective } from "./sdk-impl/magic/ms-spells.js";
 export { BINARY_EXTS, BINARY_SET } from "./sdk-impl/utils/b-exts.js";
 export { isBinaryExt } from "./sdk-impl/utils/binary.js";
 export type { CommentStyle, FileExtension, CommentMapping } from "./sdk-impl/utils/comments.js";

package/bin/libs/sdk/sdk-mod.js

@@ -106,8 +106,8 @@ export {
 } from "./sdk-impl/rules/rules-consts.js";
 export { displayCheckResults } from "./sdk-impl/rules/rules-mod.js";
 export { shouldIgnoreFile, getAllFiles, getLineNumber } from "./sdk-impl/rules/rules-utils.js";
-export { applyMagicSpells, getAllAvailableRegistries } from "./sdk-impl/magic/apply.js";
-export { evaluateMagicDirective } from "./sdk-impl/magic/spells.js";
+export { applyMagicSpells, getAllAvailableRegistries } from "./sdk-impl/magic/ms-apply.js";
+export { evaluateMagicDirective } from "./sdk-impl/magic/ms-spells.js";
 export { BINARY_EXTS, BINARY_SET } from "./sdk-impl/utils/b-exts.js";
 export { isBinaryExt } from "./sdk-impl/utils/binary.js";
 export { DEFAULT_COMMENT, COMMENT_MAP, getCommentPrefix } from "./sdk-impl/utils/comments.js";

package/package.json

@@ -35,7 +35,7 @@
     "p-all": "^5.0.0",
     "p-map": "^7.0.3",
     "pkg-types": "^2.1.0",
-    "postcss": "^8.5.4",
+    "postcss": "^8.5.5",
     "postcss-nested": "^7.0.2",
     "pretty-bytes": "^7.0.0",
     "pretty-ms": "^9.2.0",
@@ -52,7 +52,7 @@
   "license": "MIT",
   "name": "@reliverse/dler",
   "type": "module",
-  "version": "1.7.24",
+  "version": "1.7.25",
   "keywords": [
     "reliverse",
     "cli",