@sdk-usage/core 0.0.0-next-9cce549 → 0.0.0-next-aa7d62e

package/dist/index.cjs

@@ -0,0 +1,284 @@
+'use strict';
+
+var node_fs = require('node:fs');
+var node_path = require('node:path');
+var fdir = require('fdir');
+var node_module = require('node:module');
+var node_child_process = require('node:child_process');
+var core = require('@swc/core');
+var visitor = require('@open-vanilla/visitor');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+const resolvePackageJson = (fromPath)=>{
+    const filepath = node_path.join(fromPath, "./package.json");
+    if (node_fs.existsSync(filepath)) {
+        return filepath;
+    }
+    return resolvePackageJson(node_path.join(fromPath, "../"));
+};
+/**
+ * Execute an external command.
+ * @param command - The command to execute.
+ * @param options - Options including current working directory configuration.
+ * @param options.cwd - Configure the current working directory.
+ * @returns The output (either the command output or error).
+ * @example
+ * exec("ls");
+ */ const exec = async (command, options = {})=>{
+    return new Promise((resolve, reject)=>{
+        let stdout = "";
+        let stderr = "";
+        const [bin, ...arguments_] = command.split(" ");
+        // eslint-disable-next-line sonarjs/os-command
+        const childProcess = node_child_process.spawn(bin, arguments_, {
+            cwd: options.cwd,
+            shell: true,
+            stdio: "pipe"
+        });
+        childProcess.stdout.on("data", (chunk)=>{
+            stdout += chunk;
+        });
+        childProcess.stderr.on("data", (chunk)=>{
+            stderr += chunk;
+        });
+        childProcess.on("close", (exitCode)=>{
+            if (exitCode !== 0) {
+                const output = `${stderr}${stdout}`;
+                reject(new Error(output.trim()));
+            } else {
+                resolve(stdout.trim());
+            }
+        });
+    });
+};
+
+const scan = async (path, options = {})=>{
+    const excludedFolders = options.excludeFolders ?? DEFAULT_EXCLUDED_FOLDERS;
+    const includedFiles = options.includeFiles ?? DEFAULT_INCLUDED_FILES;
+    const projectPaths = new fdir.fdir().withBasePath().glob("**/package.json").exclude((directoryName)=>excludedFolders.includes(directoryName)).crawl(path).sync();
+    const projects = [];
+    for (const projectPath of projectPaths){
+        const metadata = require$1(projectPath);
+        const folder = node_path.dirname(projectPath);
+        let link;
+        try {
+            link = await exec("git config --get remote.origin.url", {
+                cwd: folder
+            });
+        } catch  {
+            link = "";
+        }
+        projects.push({
+            folder,
+            link,
+            metadata
+        });
+    }
+    return projects.map((project)=>{
+        const files = new fdir.fdir().withBasePath().glob(...includedFiles).exclude((directoryName)=>excludedFolders.includes(directoryName)).crawl(project.folder).sync();
+        return {
+            ...project,
+            files
+        };
+    });
+};
+const DEFAULT_EXCLUDED_FOLDERS = [
+    ".git",
+    "node_modules",
+    "dist",
+    "out"
+];
+const DEFAULT_INCLUDED_FILES = [
+    "**/*/!(test|*.test|stories|*.stories).?(m){j,t}s?(x)"
+];
+
+const parse = async (code, { onAdd, plugins })=>{
+    const context = {
+        imports: new Map()
+    };
+    let ast;
+    try {
+        ast = await core.parse(code, {
+            syntax: "typescript",
+            tsx: true
+        });
+    } catch  {
+        ast = undefined;
+    // TODO: log error with file path
+    }
+    if (ast === undefined) return;
+    const visitor$1 = {
+        ImportDeclaration (node) {
+            const module = node.source.value;
+            node.specifiers.forEach((specifier)=>{
+                const specifierValue = specifier.local.value;
+                context.imports.set(specifierValue, {
+                    name: // @ts-expect-error `imported` field is not exposed by `ImportSpecifier` node (issue in `@swc/core` type definition).
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                    specifier.imported?.value || specifierValue,
+                    alias: specifierValue,
+                    module
+                });
+            });
+        }
+    };
+    for (const plugin of plugins.syntax){
+        const pluginOutput = plugin(context, {
+            getJSXAttributeValue
+        });
+        const nodeKeys = Object.keys(pluginOutput);
+        for (const nodeKey of nodeKeys){
+            const currentVisitorFunction = visitor$1[nodeKey];
+            visitor$1[nodeKey] = (node)=>{
+                if (typeof currentVisitorFunction === "function") {
+                    currentVisitorFunction(node);
+                }
+                const output = pluginOutput[nodeKey]?.(node);
+                if (output) {
+                    onAdd(output);
+                }
+            };
+        }
+    }
+    visitor.visit(ast, visitor$1);
+};
+const getJSXAttributeValue = (node)=>{
+    if (!node) {
+        return true;
+    }
+    switch(node.type){
+        case "NullLiteral":
+            {
+                return null;
+            }
+        case "StringLiteral":
+        case "NumericLiteral":
+        case "BigIntLiteral":
+        case "BooleanLiteral":
+        case "JSXText":
+            {
+                return node.value;
+            }
+        case "JSXExpressionContainer":
+            {
+                return getJSXAttributeValue(node.expression);
+            }
+        case "JSXElement":
+        case "JSXFragment":
+        case "RegExpLiteral":
+        default:
+            {
+                return createUnknownToken(node.type);
+            }
+    }
+};
+/**
+ * Helper to unify the way unknown AST token are managed.
+ * @param token - AST token value.
+ * @returns Formatted AST token.
+ * @example
+ * createUnknownToken("VariableDeclaration");
+ */ const createUnknownToken = (token)=>`#${token}`;
+
+const createLocation = ({ code, file, link, module, offset, path })=>{
+    const linesTillOffset = code.slice(0, Math.max(0, offset)).split(/\n/);
+    const line = linesTillOffset.length;
+    const column = linesTillOffset[line - 1].length;
+    return {
+        column,
+        file: `./${node_path.relative(path, file)}`,
+        line,
+        link,
+        module
+    };
+};
+
+/**
+ * Aggregate factory that creates an item.
+ * @param input - Factory variables.
+ * @param input.name - Name.
+ * @param input.type - Component type.
+ * @param input.module - Source module.
+ * @param input.version - Module version.
+ * @param input.location - Location.
+ * @param input.input - Parameter list and metadata describing the way it's passed.
+ * @returns Created item.
+ * @example
+ * createItem({ ... });
+ */ const createItem = ({ name, input, location, module, type, version })=>{
+    const item = {
+        name,
+        type,
+        module,
+        version,
+        createdAt: new Date().toISOString(),
+        location: createLocation(location),
+        input: {
+            metadata: {
+                withSpreading: input?.metadata.withSpreading ?? false
+            },
+            data: input?.data ?? {}
+        }
+    };
+    return item;
+};
+
+const createContext = (path, options)=>{
+    return {
+        async getItems () {
+            const projects = await scan(path);
+            const items = [];
+            for (const project of projects){
+                const module = project.metadata.name;
+                const dependencies = {
+                    ...project.metadata.devDependencies,
+                    ...project.metadata.optionalDependencies,
+                    ...project.metadata.dependencies
+                };
+                const link = project.link;
+                for (const file of project.files){
+                    const code = node_fs.readFileSync(file, "utf8");
+                    await parse(code, {
+                        onAdd (item) {
+                            if (options.includeModules && options.includeModules.length > 0 && !options.includeModules.includes(item.module)) {
+                                return;
+                            }
+                            let version;
+                            try {
+                                version = require$1(resolvePackageJson(require$1.resolve(item.module, {
+                                    paths: [
+                                        file
+                                    ]
+                                }))).version;
+                            } catch  {
+                                version = dependencies[item.module] ?? "";
+                            }
+                            items.push(createItem({
+                                ...item,
+                                location: {
+                                    code,
+                                    file,
+                                    link,
+                                    module,
+                                    offset: item.offset,
+                                    path
+                                },
+                                version
+                            }));
+                        },
+                        plugins: options.plugins
+                    });
+                }
+            }
+            return items;
+        }
+    };
+};
+
+const createSyntaxPlugin = (input)=>{
+    return input;
+};
+
+exports.createContext = createContext;
+exports.createSyntaxPlugin = createSyntaxPlugin;

package/dist/index.d.ts

@@ -0,0 +1,99 @@
+import { ImportDeclaration, JSXAttrValue, JSXOpeningElement, TsType } from '@swc/core';
+
+type Primitive = bigint | boolean | number | string | null | undefined;
+type Nodes = {
+    ImportDeclaration: ImportDeclaration;
+    JSXAttrValue: JSXAttrValue;
+    JSXOpeningElement: JSXOpeningElement;
+    TsType: TsType;
+};
+/**
+ * Import entity to model an import statement.
+ */
+type Import = {
+    name: string;
+    alias: string;
+    module: string;
+};
+/**
+ * Package entity to model `package.json` metadata.
+ */
+type Package = {
+    name: string;
+    description: string;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    optionalDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    version: string;
+};
+
+type ScanOptions = {
+    /**
+     * A list of folders to ignore.
+     */
+    excludeFolders?: string[];
+    /**
+     * A list of files to include (following glob matcher).
+     */
+    includeFiles?: string[];
+};
+
+type Location = {
+    column: number;
+    file: string;
+    line: number;
+    link: string;
+    module: string;
+};
+
+type Item = {
+    name: string;
+    createdAt: string;
+    input: {
+        data: Record<string, unknown>;
+        metadata: {
+            withSpreading: boolean;
+        };
+    };
+    location: Location;
+    module: Package["name"];
+    type: string;
+    version: Package["version"];
+};
+type ItemDTO = Partial<Pick<Item, "input">> & Pick<Item, "module" | "name" | "type"> & {
+    offset: number;
+};
+
+declare const createSyntaxPlugin: (input: SyntaxPlugin) => SyntaxPlugin;
+type SyntaxPlugin = (context: {
+    imports: Map<Import["alias"], Import>;
+}, helpers: {
+    getJSXAttributeValue: (node: Nodes["JSXAttrValue"] | undefined) => Primitive;
+}) => {
+    [Key in keyof Nodes]?: (node: Nodes[Key]) => ItemDTO | undefined;
+};
+
+type Plugins = {
+    syntax: SyntaxPlugin[];
+};
+
+type ParseOptions = {
+    onAdd: (item: ItemDTO) => void;
+    /**
+     * A list of plugins to enable.
+     */
+    plugins: Plugins;
+};
+
+type Options = Partial<Pick<ScanOptions, "excludeFolders" | "includeFiles"> & {
+    /**
+     * Only analyze components imported from the specificied module list.
+     */
+    includeModules: string[];
+}> & Pick<ParseOptions, "plugins">;
+declare const createContext: (path: string, options: Options) => {
+    getItems(): Promise<Item[]>;
+};
+
+export { createContext, createSyntaxPlugin };

package/dist/index.mjs

@@ -0,0 +1,280 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join, dirname, relative } from 'node:path';
+import { fdir } from 'fdir';
+import { createRequire } from 'node:module';
+import { spawn } from 'node:child_process';
+import { parse as parse$1 } from '@swc/core';
+import { visit } from '@open-vanilla/visitor';
+
+const require = createRequire(import.meta.url);
+const resolvePackageJson = (fromPath)=>{
+    const filepath = join(fromPath, "./package.json");
+    if (existsSync(filepath)) {
+        return filepath;
+    }
+    return resolvePackageJson(join(fromPath, "../"));
+};
+/**
+ * Execute an external command.
+ * @param command - The command to execute.
+ * @param options - Options including current working directory configuration.
+ * @param options.cwd - Configure the current working directory.
+ * @returns The output (either the command output or error).
+ * @example
+ * exec("ls");
+ */ const exec = async (command, options = {})=>{
+    return new Promise((resolve, reject)=>{
+        let stdout = "";
+        let stderr = "";
+        const [bin, ...arguments_] = command.split(" ");
+        // eslint-disable-next-line sonarjs/os-command
+        const childProcess = spawn(bin, arguments_, {
+            cwd: options.cwd,
+            shell: true,
+            stdio: "pipe"
+        });
+        childProcess.stdout.on("data", (chunk)=>{
+            stdout += chunk;
+        });
+        childProcess.stderr.on("data", (chunk)=>{
+            stderr += chunk;
+        });
+        childProcess.on("close", (exitCode)=>{
+            if (exitCode !== 0) {
+                const output = `${stderr}${stdout}`;
+                reject(new Error(output.trim()));
+            } else {
+                resolve(stdout.trim());
+            }
+        });
+    });
+};
+
+const scan = async (path, options = {})=>{
+    const excludedFolders = options.excludeFolders ?? DEFAULT_EXCLUDED_FOLDERS;
+    const includedFiles = options.includeFiles ?? DEFAULT_INCLUDED_FILES;
+    const projectPaths = new fdir().withBasePath().glob("**/package.json").exclude((directoryName)=>excludedFolders.includes(directoryName)).crawl(path).sync();
+    const projects = [];
+    for (const projectPath of projectPaths){
+        const metadata = require(projectPath);
+        const folder = dirname(projectPath);
+        let link;
+        try {
+            link = await exec("git config --get remote.origin.url", {
+                cwd: folder
+            });
+        } catch  {
+            link = "";
+        }
+        projects.push({
+            folder,
+            link,
+            metadata
+        });
+    }
+    return projects.map((project)=>{
+        const files = new fdir().withBasePath().glob(...includedFiles).exclude((directoryName)=>excludedFolders.includes(directoryName)).crawl(project.folder).sync();
+        return {
+            ...project,
+            files
+        };
+    });
+};
+const DEFAULT_EXCLUDED_FOLDERS = [
+    ".git",
+    "node_modules",
+    "dist",
+    "out"
+];
+const DEFAULT_INCLUDED_FILES = [
+    "**/*/!(test|*.test|stories|*.stories).?(m){j,t}s?(x)"
+];
+
+const parse = async (code, { onAdd, plugins })=>{
+    const context = {
+        imports: new Map()
+    };
+    let ast;
+    try {
+        ast = await parse$1(code, {
+            syntax: "typescript",
+            tsx: true
+        });
+    } catch  {
+        ast = undefined;
+    // TODO: log error with file path
+    }
+    if (ast === undefined) return;
+    const visitor = {
+        ImportDeclaration (node) {
+            const module = node.source.value;
+            node.specifiers.forEach((specifier)=>{
+                const specifierValue = specifier.local.value;
+                context.imports.set(specifierValue, {
+                    name: // @ts-expect-error `imported` field is not exposed by `ImportSpecifier` node (issue in `@swc/core` type definition).
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                    specifier.imported?.value || specifierValue,
+                    alias: specifierValue,
+                    module
+                });
+            });
+        }
+    };
+    for (const plugin of plugins.syntax){
+        const pluginOutput = plugin(context, {
+            getJSXAttributeValue
+        });
+        const nodeKeys = Object.keys(pluginOutput);
+        for (const nodeKey of nodeKeys){
+            const currentVisitorFunction = visitor[nodeKey];
+            visitor[nodeKey] = (node)=>{
+                if (typeof currentVisitorFunction === "function") {
+                    currentVisitorFunction(node);
+                }
+                const output = pluginOutput[nodeKey]?.(node);
+                if (output) {
+                    onAdd(output);
+                }
+            };
+        }
+    }
+    visit(ast, visitor);
+};
+const getJSXAttributeValue = (node)=>{
+    if (!node) {
+        return true;
+    }
+    switch(node.type){
+        case "NullLiteral":
+            {
+                return null;
+            }
+        case "StringLiteral":
+        case "NumericLiteral":
+        case "BigIntLiteral":
+        case "BooleanLiteral":
+        case "JSXText":
+            {
+                return node.value;
+            }
+        case "JSXExpressionContainer":
+            {
+                return getJSXAttributeValue(node.expression);
+            }
+        case "JSXElement":
+        case "JSXFragment":
+        case "RegExpLiteral":
+        default:
+            {
+                return createUnknownToken(node.type);
+            }
+    }
+};
+/**
+ * Helper to unify the way unknown AST token are managed.
+ * @param token - AST token value.
+ * @returns Formatted AST token.
+ * @example
+ * createUnknownToken("VariableDeclaration");
+ */ const createUnknownToken = (token)=>`#${token}`;
+
+const createLocation = ({ code, file, link, module, offset, path })=>{
+    const linesTillOffset = code.slice(0, Math.max(0, offset)).split(/\n/);
+    const line = linesTillOffset.length;
+    const column = linesTillOffset[line - 1].length;
+    return {
+        column,
+        file: `./${relative(path, file)}`,
+        line,
+        link,
+        module
+    };
+};
+
+/**
+ * Aggregate factory that creates an item.
+ * @param input - Factory variables.
+ * @param input.name - Name.
+ * @param input.type - Component type.
+ * @param input.module - Source module.
+ * @param input.version - Module version.
+ * @param input.location - Location.
+ * @param input.input - Parameter list and metadata describing the way it's passed.
+ * @returns Created item.
+ * @example
+ * createItem({ ... });
+ */ const createItem = ({ name, input, location, module, type, version })=>{
+    const item = {
+        name,
+        type,
+        module,
+        version,
+        createdAt: new Date().toISOString(),
+        location: createLocation(location),
+        input: {
+            metadata: {
+                withSpreading: input?.metadata.withSpreading ?? false
+            },
+            data: input?.data ?? {}
+        }
+    };
+    return item;
+};
+
+const createContext = (path, options)=>{
+    return {
+        async getItems () {
+            const projects = await scan(path);
+            const items = [];
+            for (const project of projects){
+                const module = project.metadata.name;
+                const dependencies = {
+                    ...project.metadata.devDependencies,
+                    ...project.metadata.optionalDependencies,
+                    ...project.metadata.dependencies
+                };
+                const link = project.link;
+                for (const file of project.files){
+                    const code = readFileSync(file, "utf8");
+                    await parse(code, {
+                        onAdd (item) {
+                            if (options.includeModules && options.includeModules.length > 0 && !options.includeModules.includes(item.module)) {
+                                return;
+                            }
+                            let version;
+                            try {
+                                version = require(resolvePackageJson(require.resolve(item.module, {
+                                    paths: [
+                                        file
+                                    ]
+                                }))).version;
+                            } catch  {
+                                version = dependencies[item.module] ?? "";
+                            }
+                            items.push(createItem({
+                                ...item,
+                                location: {
+                                    code,
+                                    file,
+                                    link,
+                                    module,
+                                    offset: item.offset,
+                                    path
+                                },
+                                version
+                            }));
+                        },
+                        plugins: options.plugins
+                    });
+                }
+            }
+            return items;
+        }
+    };
+};
+
+const createSyntaxPlugin = (input)=>{
+    return input;
+};
+
+export { createContext, createSyntaxPlugin };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdk-usage/core",
-  "version": "0.0.0-next-9cce549",
+  "version": "0.0.0-next-aa7d62e",
   "description": "sdk-usage core functionalities",
   "keywords": [
     "analyze",