@komaci/cli 0.0.1

package/README.md

@@ -0,0 +1,55 @@
+# `@komaci/cli`
+
+CLI tool to test out functionality for komaci. Currently supports only one command, `modgen`.
+
+## `modgen` Command
+
+This command will generate a komaci module, similar to what [komaci-tester](https://github.com/salesforce/komaci-tester) did, but with some improvements. Some example components can be found in `./sandbox`.
+
+One important difference is that the component's namespace is no longer hardcoded to "c". It will now be derived from the module structure. For instance;
+
+```text
+sandbox
+├── jsconfig.json
+└── modules              // LWC 'modules' directory; not required
+    ├── c                // "c" is the namespace for the modules within this directory
+    │   └── komaciAction // "lightning/komaciAction" component — komaciAction in the "c" namespace
+    └── lightning        // "lightning" is the namespace for the modules below
+        ├── komaciAction // "lightning/komaciAction" component — Same as c/komaciAction, but in a trusted namespace
+        └── recordForm   // "lightning/recordForm" component — copied from ui-lightning-components
+```
+
+### Usage
+
+Run the following from the `packages/@komaci/cli` directory:
+
+```sh
+yarn
+yarn build
+# Run modgen on the component defined @ <path>
+yarn komaci modgen <path>
+```
+
+### Examples
+
+```sh
+# Run modgen on c/komaciAction:
+yarn komaci modgen sandbox/modules/c/komaciAction
+# Print only the lwc metadata for c/komaciAction:
+yarn komaci modgen sandbox/modules/c/komaciAction --only lwc
+```
+
+Modgen can also take in a list of paths:
+
+```sh
+yarn komaci modgen sandbox/modules/lightning/komaciAction sandbox/modules/lightning/recordForm
+```
+
+If all the modules are in the same subdirectory, you can use a glob pattern:
+
+```sh
+# Run modgen on all modules in the lightning namespace:
+yarn komaci modgen sandbox/modules/lightning/*
+# Run modgen on all modules in all namespaces:
+yarn komaci modgen sandbox/modules/*/*
+```

package/bin/komaci.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import('../build/index.js');

package/build/cmds/index.d.ts

@@ -0,0 +1,3 @@
+import modgen from './modgen/index.js';
+export { modgen };
+//# sourceMappingURL=index.d.ts.map

package/build/cmds/index.js

@@ -0,0 +1,3 @@
+import modgen from './modgen/index.js';
+export { modgen };
+//# sourceMappingURL=index.js.map

package/build/cmds/modgen/index.d.ts

@@ -0,0 +1,6 @@
+import type { Command } from '../../types';
+import type { ModGenOptions } from './types';
+declare const _default: Command<ModGenOptions>;
+export default _default;
+export * from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/build/cmds/modgen/index.js

@@ -0,0 +1,42 @@
+import { run } from './lib/run.js';
+export default {
+    name: 'modgen',
+    alias: 'm',
+    options: [
+        {
+            name: 'paths',
+            alias: 'p',
+            multiple: true,
+            type: String,
+            required: true,
+            defaultOption: true,
+        },
+        {
+            name: 'only',
+            alias: 'o',
+            type: String,
+            multiple: true,
+            defaultValue: ['mod', 'lwc', 'doc'],
+        },
+        {
+            name: 'disableKomaci',
+            alias: 'd',
+            type: Boolean,
+        },
+        {
+            name: 'bundleType',
+            alias: 't',
+            type: String,
+            defaultValue: 'internal',
+        },
+        {
+            name: 'json',
+            alias: 'j',
+            type: Boolean,
+            defaultValue: false,
+        },
+    ],
+    run,
+};
+export * from './types.js';
+//# sourceMappingURL=index.js.map

package/build/cmds/modgen/lib/readAndParseBundle.d.ts

@@ -0,0 +1,26 @@
+import { BundleConfig } from '@lwc-platform/lwc-metadata-next';
+import { ParsedBundle } from '../types';
+/**
+ * typeof BundleConfig.file
+ */
+declare type BundleFile = {
+    fileName: string;
+    source: string;
+};
+/**
+ * Finds all .js, .mjs, .css, and .html files within the given directory, reads their contents, and combines them into a bundle,
+ * and returning the array of BundleFile containing the file's fileName and source
+ * @param path
+ * @returns An array of BundleFile
+ */
+export declare function readBundle(path: string): BundleFile[];
+/**
+ * Takes the directory path of an LWC module bundle and an optional set of config overrides. Returns the ParsedBundle, inlcuding
+ * the bundle's 1) LWC Metadata and 2) Komaci / Resolvable module.
+ * @param path
+ * @param configOverrides
+ * @returns ParsedBundle that includes the BundleConfig & GeneratorInput inputs, and BundleMetadata and generated module output
+ */
+export declare function readAndParseBundle(path: string, configOverrides: Partial<BundleConfig>): ParsedBundle;
+export {};
+//# sourceMappingURL=readAndParseBundle.d.ts.map

package/build/cmds/modgen/lib/readAndParseBundle.js

@@ -0,0 +1,69 @@
+import { readdirSync, existsSync, readFileSync } from 'fs';
+import { basename, dirname, extname, resolve } from 'path';
+import { collectBundleMetadata } from '@lwc-platform/lwc-metadata-next';
+import { generateKomaciModule } from '@komaci/esm-generator';
+/**
+ * Finds all .js, .mjs, .css, and .html files within the given directory, reads their contents, and combines them into a bundle,
+ * and returning the array of BundleFile containing the file's fileName and source
+ * @param path
+ * @returns An array of BundleFile
+ */
+export function readBundle(path) {
+    path = resolve(path);
+    if (existsSync(path)) {
+        const contents = readdirSync(path);
+        const LWC_EXT = ['.js', '.mjs', '.css', '.html'];
+        const lwcBundleFiles = contents.filter((filename) => {
+            return LWC_EXT.includes(extname(filename));
+        });
+        return lwcBundleFiles.map((fileName) => ({
+            fileName,
+            source: readFileSync(resolve(path, fileName), 'utf-8').toString(),
+        }));
+    }
+    else {
+        throw new Error(`path doesn't exist: ${path}`);
+    }
+}
+/**
+ * Takes the directory path of an LWC module bundle and an optional set of config overrides. Returns the ParsedBundle, inlcuding
+ * the bundle's 1) LWC Metadata and 2) Komaci / Resolvable module.
+ * @param path
+ * @param configOverrides
+ * @returns ParsedBundle that includes the BundleConfig & GeneratorInput inputs, and BundleMetadata and generated module output
+ */
+export function readAndParseBundle(path, configOverrides) {
+    const files = readBundle(path);
+    const name = basename(path);
+    const namespace = basename(dirname(path));
+    const bundleConfig = {
+        namespace,
+        name,
+        type: 'internal',
+        namespaceMapping: {},
+        files,
+        enableKomaci: true,
+        ...configOverrides,
+    };
+    const metadata = collectBundleMetadata(bundleConfig);
+    // Create input to module generator.
+    const srcFileMap = files.reduce((map, { fileName, source }) => ({ ...map, [fileName]: source }), {});
+    const inputFiles = Object.fromEntries(metadata.files
+        .map(({ fileName, komaciDoc }) => [fileName, komaciDoc])
+        .filter(([, komaciDoc]) => !!komaciDoc));
+    const generatorInput = {
+        moduleInfo: {
+            name,
+            namespace: bundleConfig.namespace,
+            type: 'bundle',
+            files: inputFiles,
+        },
+        srcFileMap,
+    };
+    const modGenOutput = generateKomaciModule(generatorInput);
+    return {
+        input: { bundleConfig, generatorInput },
+        output: { modGenOutput, metadata },
+    };
+}
+//# sourceMappingURL=readAndParseBundle.js.map

package/build/cmds/modgen/lib/run.d.ts

@@ -0,0 +1,7 @@
+import type { ModGenOptions } from '../index.js';
+/**
+ * Runs the modgen command with the given Command Options.
+ * @param cmdOptions
+ */
+export declare function run(cmdOptions: ModGenOptions): void;
+//# sourceMappingURL=run.d.ts.map

package/build/cmds/modgen/lib/run.js

@@ -0,0 +1,52 @@
+import { readAndParseBundle } from './readAndParseBundle.js';
+import logger, { serialize } from '../../../lib/log.js';
+const { log, warn } = logger;
+/**
+ * Runs the modgen command with the given Command Options.
+ * @param cmdOptions
+ */
+export function run(cmdOptions) {
+    const { paths = [], disableKomaci = false, bundleType: type } = cmdOptions;
+    if (paths.length) {
+        const parsedBundles = paths.map((path) => readAndParseBundle(path, { enableKomaci: !disableKomaci, type }));
+        for (const parsedBundle of parsedBundles) {
+            const { input: { bundleConfig = null } = {}, output } = parsedBundle || {};
+            const { type, namespace, name, namespaceMapping = {}, enableKomaci = false, files = [], } = bundleConfig || {};
+            const fileNames = files.map(({ fileName }) => fileName);
+            const toPrint = { type, namespace, name, namespaceMapping, enableKomaci, fileNames, output };
+            printOutput(cmdOptions, toPrint);
+        }
+    }
+    else {
+        warn('Please provide 1 or more paths to a LWC bundle directory.');
+    }
+}
+/**
+ * TODO: jsdoc
+ * @param cmdOptions
+ * @param toPrint
+ */
+function printOutput(cmdOptions, toPrint) {
+    const { output: { metadata, modGenOutput } = {} } = toPrint;
+    const { json, only = [] } = cmdOptions;
+    if (only.includes('lwc')) {
+        log('===== LWC Metadata =====');
+        log(serialize(metadata, !json));
+    }
+    if (only.includes('doc')) {
+        const files = (metadata?.files ?? []);
+        const docs = files
+            .filter(({ fileType }) => ['js', 'html'].includes(fileType))
+            .map((file) => [file.fileName, file.komaciDoc]);
+        for (const [fileName, doc] of docs) {
+            log('===== Komaci Document =====');
+            log(`===== ${fileName} =====`);
+            log(serialize(doc, !json));
+        }
+    }
+    if (only.includes('mod')) {
+        log('===== Komaci Module =====');
+        log(modGenOutput);
+    }
+}
+//# sourceMappingURL=run.js.map

package/build/cmds/modgen/types.d.ts

@@ -0,0 +1,22 @@
+import { CommandLineOptions } from 'command-line-args';
+import type { BundleType } from '@lwc-platform/lwc-metadata-next/dist/shared/config';
+import { BundleConfig, BundleMetadata } from '@lwc-platform/lwc-metadata-next';
+import { GeneratorInput } from '@komaci/esm-generator';
+export declare type ParsedBundle = {
+    input: {
+        bundleConfig: BundleConfig;
+        generatorInput: GeneratorInput;
+    };
+    output: {
+        metadata: BundleMetadata;
+        modGenOutput: string;
+    };
+};
+export interface ModGenOptions extends CommandLineOptions {
+    paths: string[];
+    only: string[];
+    disableKomaci: boolean;
+    bundleType: BundleType;
+    json: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/build/cmds/modgen/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/build/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/build/index.js

@@ -0,0 +1,18 @@
+import commandLineArgs from 'command-line-args';
+import { modgen } from './cmds/index.js';
+import { commander } from './lib/commander.js';
+import logger from './lib/log.js';
+import chalk from 'chalk';
+const { info, error } = logger;
+const optionDefinitions = [{ name: 'command', defaultOption: true }];
+const mainCommand = commandLineArgs(optionDefinitions, { stopAtFirstUnknown: true });
+const { command, _unknown: argv = [] } = mainCommand;
+info(chalk.cyan(`Command: ${chalk.bgCyan(chalk.black(command))}.`));
+if (!commander(command, argv, [modgen])) {
+    error(`No command "${command}" found`);
+    process.exit(1);
+}
+else {
+    process.exit(0);
+}
+//# sourceMappingURL=index.js.map

package/build/lib/commander.d.ts

@@ -0,0 +1,6 @@
+import { CommandLineOptions } from 'command-line-args';
+import type { Command } from '../types';
+declare type Commands = Command<CommandLineOptions>;
+export declare function commander(commandToRun: string, argv: string[], commands: Commands[]): boolean;
+export {};
+//# sourceMappingURL=commander.d.ts.map

package/build/lib/commander.js

@@ -0,0 +1,14 @@
+import commandLineArgs from 'command-line-args';
+export function commander(commandToRun, argv, commands) {
+    const matched = commands.find(({ name, alias }) => {
+        return commandToRun === name || commandToRun === alias;
+    });
+    if (matched) {
+        const { options = [], run } = matched;
+        const commandOptions = commandLineArgs(options, { argv });
+        run(commandOptions);
+        return true;
+    }
+    return false;
+}
+//# sourceMappingURL=commander.js.map

package/build/lib/log.d.ts

@@ -0,0 +1,23 @@
+declare type FnArg = string | number | boolean | Record<string, unknown> | Array<unknown>;
+declare type Args<T = FnArg> = T;
+/**
+ * @param obj to serialize
+ * @param [pretty=true] Limits depth to 5 and adds color
+ * @returns Seralized version of the object,
+ */
+export declare function serialize(obj: unknown, pretty?: boolean): string;
+declare const _default: {
+    log: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+    trace: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+    error: (...args: Args[]) => void;
+    warn: (...args: Args[]) => void;
+    info: (...args: Args[]) => void;
+};
+export default _default;
+//# sourceMappingURL=log.d.ts.map

package/build/lib/log.js

@@ -0,0 +1,27 @@
+import chalk from 'chalk';
+import { inspect } from 'util';
+const { error, log, trace, warn, info } = console;
+const { red, yellow, blue } = chalk;
+/**
+ * @param obj to serialize
+ * @param [pretty=true] Limits depth to 5 and adds color
+ * @returns Seralized version of the object,
+ */
+export function serialize(obj, pretty = true) {
+    const options = pretty ? { depth: 5, colors: true } : { depth: Infinity };
+    return inspect(obj, options);
+}
+export default {
+    log,
+    trace,
+    error: (...args) => {
+        return error(...[red('error'), ...args]);
+    },
+    warn: (...args) => {
+        return warn(...[yellow('w⚠rn'), ...args]);
+    },
+    info: (...args) => {
+        return info(...[blue('ℹnfo'), ...args]);
+    },
+};
+//# sourceMappingURL=log.js.map

package/build/types.d.ts

@@ -0,0 +1,8 @@
+import type { CommandLineOptions, OptionDefinition } from 'command-line-args';
+export declare type Command<T extends CommandLineOptions> = {
+    name: string;
+    alias?: string;
+    run: (cmdOptions: T) => void;
+    options: OptionDefinition[];
+};
+//# sourceMappingURL=types.d.ts.map

package/build/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/package.json

@@ -0,0 +1,47 @@
+{
+    "name": "@komaci/cli",
+    "version": "0.0.1",
+    "description": "CLI utility that enables developers to use komaci from the command line.",
+    "license": "MIT",
+    "type": "module",
+    "types": "build/index.d.ts",
+    "main": "build/index.js",
+    "module": "build/index.js",
+    "files": [
+        "build/**/*.js",
+        "build/**/*.d.ts"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/salesforce/komaci.git",
+        "directory": "packages/@komaci/cli"
+    },
+    "scripts": {
+        "build": "tsc -b",
+        "komaci": "./packages/@komaci/cli/bin/komaci.js"
+    },
+    "bugs": {
+        "url": "https://github.com/AndrewHuffman/komaci/issues"
+    },
+    "dependencies": {
+        "@komaci/esm-generator": "0.0.1",
+        "@lwc-platform/lwc-metadata-next": "^2.18.0-240.2",
+        "chalk": "^5.0.1",
+        "command-line-args": "^5.2.1"
+    },
+    "devDependencies": {
+        "@types/command-line-args": "^5.2.0",
+        "@types/node": "^17.0.22"
+    },
+    "exports": {
+        ".": {
+            "import": "./build/index.js"
+        }
+    },
+    "volta": {
+        "node": "14.19.1"
+    },
+    "bin": {
+        "komaci": "./bin/komaci.js"
+    }
+}