npm - neutrinos-cli - Versions diffs - 1.0.0 - Mend

neutrinos-cli 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (57) hide show

package/.configs/auth.json +5 -0
package/.configs/preferences.json +5 -0
package/.env +6 -0
package/README.md +173 -0
package/bin/cli.js +239 -0
package/cli-auth/auth.js +54 -0
package/cli-auth/publish.js +7 -0
package/cli-auth/server.js +44 -0
package/cli-auth/services/auth-utils.js +68 -0
package/commands/alpha-publish.js +219 -0
package/commands/attribute.js +155 -0
package/commands/build.js +83 -0
package/commands/deprecate.js +88 -0
package/commands/dev.js +21 -0
package/commands/generate.js +19 -0
package/commands/new-workspace.js +142 -0
package/commands/publish.js +334 -0
package/commands/select-packages.mjs +36 -0
package/commands/serve.js +27 -0
package/package.json +34 -0
package/setup.js +55 -0
package/templates/assets/default-icon.png +0 -0
package/templates/component/.component.ts.hbs +126 -0
package/templates/component/.spec.ts.hbs +15 -0
package/templates/component/.styles.ts.hbs +2 -0
package/templates/module/.module.js.hbs +11 -0
package/templates/plugins-server/index.js +18 -0
package/templates/project/.vscode/extensions.json +6 -0
package/templates/project/ATTRIBUTE.md +127 -0
package/templates/project/Dockerfile +15 -0
package/templates/project/helmchart/.helmignore +23 -0
package/templates/project/helmchart/Chart.yaml +24 -0
package/templates/project/helmchart/templates/NOTES.txt +22 -0
package/templates/project/helmchart/templates/_helpers.tpl +62 -0
package/templates/project/helmchart/templates/deployment.yaml +69 -0
package/templates/project/helmchart/templates/ingress.yaml +62 -0
package/templates/project/helmchart/templates/service.yaml +14 -0
package/templates/project/helmchart/values.yaml +74 -0
package/templates/project/index.html +24 -0
package/templates/project/index.ts +86 -0
package/templates/project/public-api.ts +0 -0
package/templates/project/tsconfig.json +27 -0
package/utils/attribute-utils.js +149 -0
package/utils/check-valid-ws.js +21 -0
package/utils/copy-utils.js +68 -0
package/utils/create-client.js +23 -0
package/utils/file-utils.js +43 -0
package/utils/generate-component.js +101 -0
package/utils/generate-module.js +51 -0
package/utils/get-package-info.js +53 -0
package/utils/get-packages.js +15 -0
package/utils/inquirer-utils.js +49 -0
package/utils/logger.js +35 -0
package/utils/marketplace-api-utils.js +34 -0
package/utils/path-utils.js +40 -0
package/utils/prettify.js +36 -0
package/utils/user-seesion-utils.js +43 -0

package/templates/project/index.html ADDED Viewed

@@ -0,0 +1,24 @@
+<!doctype html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>Components</title>
+        <style alphaGlobalStyle>
+            /*
+                Global styles with alphaGlobalStyle directive. This will be available in all components.
+                example render output: html`<div class="small-1">Hello World</div>`
+             */
+            .small-1 {
+                font-size: 12px;
+            }
+            .small-2 {
+                color: red;
+            }
+        </style>
+    </head>
+    <body style="padding: 1rem; box-sizing: border-box">
+        <div id="app"></div>
+        <script type="module" src="./index.ts"></script>
+    </body>
+</html>

package/templates/project/index.ts ADDED Viewed

@@ -0,0 +1,86 @@
+import * as _cs from './public-api.ts';
+declare global {
+    interface Window {
+        alpha: any;
+        ap: any;
+    }
+}
+const setup = () => {
+    const style = document.createElement('style');
+    document.querySelector('head')?.appendChild(style);
+};
+/**
+ * Store all the component instances in globalThis.aci
+ * for testing purposes
+ */
+globalThis.aci = {} as any;
+const addComponent = (name: string, { inputs, outputs }: ComponentConfig) => {
+    const customElem = document.createElement(name) as any;
+    const fieldSet = document.createElement('fieldset');
+    const legend = document.createElement('legend');
+    legend.textContent = name;
+    fieldSet.appendChild(legend);
+    const key = name.slice('alpha'.length + 1);
+    (globalThis.aci[key] = globalThis.aci[key] || []).push(customElem);
+    for (let [key, val] of Object.entries(inputs || {})) {
+        customElem[key] = val;
+        const input = document.createElement('input');
+        input.type = 'text';
+        input.value = val;
+        input.placeholder = key;
+        input.addEventListener('change', (e) => {
+            customElem[key] = (e.target as any).value;
+        });
+        fieldSet.appendChild(input);
+    }
+    fieldSet.appendChild(customElem);
+    const outputEvents = outputs?.events || ['change'];
+    outputEvents.forEach((event) => {
+        customElem.addEventListener(event, (e: any) => {
+            console.log(`[${name}][event:${event}]`, e);
+        });
+    });
+    document.body.appendChild(fieldSet);
+};
+const components: Record<string, ComponentConfig> = (() => {
+    console.log(_cs);
+    const comps = {};
+    for (const [_, _class] of Object.entries(_cs)) {
+        const inputs = Reflect.getMetadata('AlphaAttribute', _class.prototype);
+        const c = Reflect.getMetadata('AlphaComponent', _class.prototype);
+        const selector = `${c.selector}-${c.componentVersion}`;
+        comps[selector] = {
+            inputs: inputs?.reduce((acc, { fieldMappings, defaultValue }) => {
+                acc[fieldMappings] = defaultValue ?? '';
+                return acc;
+            }, {}),
+            outputs: {
+                events: ['change'],
+            },
+        };
+    }
+    return comps;
+})();
+document.addEventListener('DOMContentLoaded', async () => {
+    setup();
+    for (let [name, config] of Object.entries(components)) {
+        addComponent(name, config);
+    }
+});
+interface ComponentConfig {
+    class?: string;
+    inputs?: {
+        disabled?: boolean;
+        readonly?: boolean;
+        value?: any;
+        name?: any;
+        id?: any;
+        [key: string]: any;
+    };
+    outputs?: {
+        events: string[];
+    };
+}

package/templates/project/public-api.ts ADDED Viewed

File without changes

package/templates/project/tsconfig.json ADDED Viewed

@@ -0,0 +1,27 @@
+{
+    "compilerOptions": {
+        "target": "ES2020",
+        "module": "ESNext",
+        "lib": ["ES2020", "DOM", "DOM.Iterable"],
+        "skipLibCheck": true,
+        /* Bundler mode */
+        "moduleResolution": "bundler",
+        "allowImportingTsExtensions": true,
+        "resolveJsonModule": true,
+        "isolatedModules": true,
+        "noEmit": true,
+        /* Decorators Support */
+        "experimentalDecorators": true,
+        "emitDecoratorMetadata": true,
+        "useDefineForClassFields": false,
+        /* Linting */
+        // "strict": true,
+        "noUnusedLocals": true,
+        "noUnusedParameters": true,
+        "noFallthroughCasesInSwitch": true
+    },
+    "include": ["packages", "index.ts"]
+}

package/utils/attribute-utils.js ADDED Viewed

@@ -0,0 +1,149 @@
+//@ts-check
+import { basename, join, sep } from 'node:path';
+import { MethodDeclaration, Project, SyntaxKind } from 'ts-morph';
+import { done, inprogress } from './logger.js';
+import { getGeneratedComponentClassName, getGeneratedComponentName } from './path-utils.js';
+export const updateComponentSource = (attrMetadata, wsPath, packagePath, name) => {
+    inprogress('Adding the attribute to the package: ' + name);
+    const project = new Project({
+        tsConfigFilePath: join(wsPath, 'tsconfig.json'),
+    });
+    const sourceFile = project.addSourceFileAtPath(
+        join(packagePath, getGeneratedComponentName(basename(packagePath)) + '.ts'),
+    );
+    const fieldMappings = [];
+    if (attrMetadata.fieldMappings) {
+        if (typeof attrMetadata.fieldMappings === 'object') {
+            Object.keys(attrMetadata.fieldMappings).forEach((f) => {
+                fieldMappings.push(attrMetadata.fieldMappings[f]);
+            });
+        } else {
+            fieldMappings.push(attrMetadata.fieldMappings);
+        }
+    }
+    const classDeclaration = sourceFile.getClassOrThrow(getGeneratedComponentClassName(basename(packagePath)));
+    addDecorator(classDeclaration, fieldMappings, attrMetadata);
+    sourceFile.saveSync();
+    done('Attribute added successfully');
+};
+const addDecorator = (classDeclaration, fieldMappings, attrMetadata) => {
+    if (attrMetadata.type === 'ATTRIBUTE_TYPE.EVENT') {
+        addEventTypeDecorator(classDeclaration, attrMetadata);
+    } else {
+        addPropertyDecorator(classDeclaration, fieldMappings, attrMetadata);
+    }
+};
+const addEventTypeDecorator = (classDeclaration, attrMetadata) => {
+    let renderFunction = classDeclaration.getMethod('render');
+    if (!(renderFunction instanceof MethodDeclaration)) {
+        renderFunction = classDeclaration.getMethods()[0];
+    }
+    renderFunction.addDecorator({
+        name: 'AlphaAttribute',
+        arguments: [(writer) => writeDecoratorArguments(writer, attrMetadata)],
+    });
+};
+const addPropertyDecorator = (classDeclaration, fieldMappings, attrMetadata) => {
+    const properties = classDeclaration.getProperties();
+    let property = properties[0];
+    if (fieldMappings.length) {
+        fieldMappings.forEach((f) => {
+            const fieldMapping = f.split('.');
+            const propertyName = fieldMapping[0];
+            const prop = properties.find((p) => p.getName() === propertyName);
+            if (prop) {
+                property = prop;
+                return;
+            }
+        });
+    }
+    property.addDecorator({
+        name: 'AlphaAttribute',
+        arguments: [(writer) => writeDecoratorArguments(writer, attrMetadata)],
+    });
+};
+const writeDecoratorArguments = (writer, attrMetadata) => {
+    writer.write('{\n');
+    Object.entries(attrMetadata).forEach(([key, value], index, array) => {
+        writer.write(`\t${key}: `);
+        if (key === 'type' || key === 'uiType') {
+            writer.write(value);
+        } else if (typeof value === 'string') {
+            writer.quote(value);
+        } else {
+            writeObjectType(writer, value);
+        }
+        if (index < array.length - 1) {
+            writer.write(', \n');
+        }
+    });
+    writer.write('\n}');
+};
+const writeObjectType = (writer, attr) => {
+    if (Array.isArray(attr)) {
+        writer.write('[');
+        attr.forEach((element, index) => {
+            writeObjectType(writer, element);
+            if (index < attr.length - 1) {
+                writer.write(', ');
+            }
+        });
+        writer.write(']');
+    } else if (typeof attr === 'object' && attr !== null) {
+        writer.write('{');
+        Object.entries(attr).forEach(([key, val], index, array) => {
+            writer.write(`${key}: `);
+            writeObjectType(writer, val);
+            if (index < array.length - 1) {
+                writer.write(', ');
+            }
+        });
+        writer.write('}');
+    } else {
+        writer.quote(attr || '');
+    }
+};
+/**
+ * Updates the `componentVersion` property in the `@AlphaComponent` decorator.
+ * @param packageDir - The directory containing TypeScript files.
+ * @param version - The new version to set.
+ */
+export function getAlphaComponentDecorator(packageDir) {
+    try {
+        const project = new Project();
+        const packageName = packageDir.split(sep).pop();
+        const sourceFile = project.addSourceFilesAtPaths(`${packageDir}/${packageName}.ts`) || [];
+        const classes = sourceFile[0]?.getClasses();
+        for (const classDeclaration of classes) {
+            const alphaComponentDecorator = classDeclaration.getDecorator('AlphaComponent');
+            if (!alphaComponentDecorator) {
+                const customElementDecorator = classDeclaration.getDecorator('customElement');
+                if (customElementDecorator) {
+                    return {
+                        label: (customElementDecorator.getArguments() || [])[0]?.getLiteralText(),
+                    };
+                }
+                continue;
+            } else {
+                const args = alphaComponentDecorator.getArguments()[0];
+                if (!args || !args.isKind(SyntaxKind.ObjectLiteralExpression)) return;
+                return {
+                    label: args.getProperty('label')?.getInitializer()?.getLiteralText(),
+                    icon: args.getProperty('icon')?.getInitializer()?.getLiteralText(),
+                };
+            }
+        }
+        return null;
+    } catch (error) {
+        console.warn(`Error updating component version: ${error.message}`);
+    }
+}

package/utils/check-valid-ws.js ADDED Viewed

@@ -0,0 +1,21 @@
+import { existsSync } from 'fs';
+import { join } from 'node:path';
+import { failed } from './logger.js';
+export const validateWorkspace = (dir) => {
+    if (!dir) {
+        failed('Please provide a valid workspace name');
+        return false;
+    }
+    const pluginJson = join(dir, 'plugin.json');
+    if (!existsSync(pluginJson)) {
+        failed(`Workspace's plugin.json does not exist`);
+        return false;
+    }
+    const packageJson = join(dir, 'package.json');
+    if (!existsSync(packageJson)) {
+        failed(`Workspace's package.json does not exist`);
+        return false;
+    }
+    return true;
+};

package/utils/copy-utils.js ADDED Viewed

@@ -0,0 +1,68 @@
+//@ts-check
+import { copyFileSync, cpSync, existsSync, mkdir, mkdirSync, readdirSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+export const copyDefaultAssetsToPackage = (packageDirPath) => {
+    copyIconDir(packageDirPath);
+    copyImagesDir(packageDirPath);
+};
+const getPackageIconDirPath = (packageDirPath) => {
+    return join(packageDirPath, 'assets/icon');
+};
+export const getPackageAssetsDirPath = (packageDirPath) => {
+    return join(packageDirPath, 'assets/');
+};
+const getPackageImagesDirPath = (packageDirPath) => {
+    return join(packageDirPath, 'assets/images');
+};
+const copyIconDir = (dir) => {
+    cpSync(join(__dirname, '../templates/assets'), getPackageIconDirPath(dir), {
+        recursive: true,
+    });
+};
+const copyImagesDir = (dir) => {
+    cpSync(join(__dirname, '../templates/assets'), getPackageImagesDirPath(dir), {
+        recursive: true,
+    });
+};
+export const copyIconToAsset = (iconPath, packageDirPath) => {
+    const iconAssetPath = getPackageIconDirPath(packageDirPath);
+    if (!existsSync(iconAssetPath)) {
+        mkdirSync(iconAssetPath, { recursive: true });
+    }
+    copyFileSync(iconPath, join(iconAssetPath, basename(iconPath)));
+};
+export const copyImagesToAsset = (imagePath, packageDirPath) => {
+    const imagesAssetPath = getPackageImagesDirPath(packageDirPath);
+    if (!existsSync(imagesAssetPath)) {
+        mkdir(imagesAssetPath, { recursive: true }, (err) => {
+            if (err) throw err;
+        });
+    }
+    copyFileSync(imagePath, join(imagesAssetPath, basename(imagePath)));
+};
+export const getPackageIcon = (packageDirPath) => {
+    const pkgIconDirPath = getPackageIconDirPath(packageDirPath);
+    const icon = existsSync(pkgIconDirPath) ? readdirSync(pkgIconDirPath) : [];
+    if (icon && icon.length) {
+        return join(pkgIconDirPath, icon[0]);
+    }
+    return null;
+};
+export const getPackageImages = (packageDirPath) => {
+    const pkgImageDirPath = getPackageImagesDirPath(packageDirPath);
+    return ((existsSync(pkgImageDirPath) ? readdirSync(pkgImageDirPath) : []) || []).map((img) => {
+        return join(pkgImageDirPath, img);
+    });
+};

package/utils/create-client.js ADDED Viewed

@@ -0,0 +1,23 @@
+//@ts-check
+import { env } from 'node:process';
+import { Issuer } from 'openid-client';
+export const createClient = async () => {
+    if (!env.ISSUER_URL) {
+        console.error('Issuer URL not found');
+        return;
+    }
+    const issuer = await Issuer.discover(env.ISSUER_URL);
+    if (!issuer) {
+        console.error('Issuer not found');
+        return;
+    }
+    if (!env.IDS_CLIENT_ID || !env.IDS_CLIENT_SECRET) {
+        console.error('Client ID or Client Secret not found');
+        return;
+    }
+    const client = new issuer.Client({
+        client_id: env.IDS_CLIENT_ID,
+        client_secret: env.IDS_CLIENT_SECRET,
+    });
+    return client;
+};

package/utils/file-utils.js ADDED Viewed

@@ -0,0 +1,43 @@
+//@ts-check
+import AdmZip from 'adm-zip';
+import { execSync } from 'node:child_process';
+import { createReadStream, existsSync, readFileSync, unlink, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { copyIconToAsset } from './copy-utils.js';
+import { failed } from './logger.js';
+export const createZipArchive = async (directoryPath, packageName, wsPath, isModule) => {
+    const buildCommand = `alpha build plugins ${packageName} ${isModule ? '--module' : ''}`;
+    execSync(buildCommand, {
+        cwd: wsPath,
+        stdio: 'inherit',
+    });
+    const zip = AdmZip();
+    zip.addLocalFolder(directoryPath);
+    const zipBuffer = zip.toBuffer();
+    const zipFilePath = join(directoryPath, `${packageName.toLowerCase()}.zip`);
+    writeFileSync(zipFilePath, zipBuffer);
+    const zipStream = createReadStream(zipFilePath);
+    zipStream.on('close', () => unlink(zipFilePath, () => new Error('Error deleting zip file')));
+    return zipStream;
+};
+export function getPackageJson(packageJsonPath) {
+    return JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+}
+export function getIconStream(iconPath, packageDirPath) {
+    if (existsSync(iconPath)) {
+        copyIconToAsset(iconPath, packageDirPath);
+        return getFileReadableStream(iconPath);
+    }
+    return null;
+}
+export function getFileReadableStream(filePath) {
+    return existsSync(filePath) ? createReadStream(filePath) : failed("Invalid file path or file doesn't exist");
+}

package/utils/generate-component.js ADDED Viewed

@@ -0,0 +1,101 @@
+//@ts-check
+import { pascalCase, sentenceCase } from 'change-case';
+import { bold } from 'colorette';
+import handlebars from 'handlebars';
+import { execSync } from 'node:child_process';
+// prettier-ignore
+import { existsSync,mkdirSync,readFileSync,rmSync,writeFileSync } from 'node:fs';
+import { appendFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { copyDefaultAssetsToPackage } from './copy-utils.js';
+import { done, failed, inprogress } from './logger.js';
+import { componentTemplatesPath, getGeneratedComponentName } from './path-utils.js';
+import { prettify } from './prettify.js';
+export const generateComponentPackageInWorkspace = async (wsPath, name, description) => {
+    const componentDir = join(wsPath, 'packages', name);
+    if (existsSync(componentDir)) {
+        failed(`Component ${componentDir} already exists`, new Error());
+        process.exit(1);
+    }
+    try {
+        inprogress(`Generating component package with name: ${bold(name)}`);
+        execSync(`npm init -y -w packages/${name}`);
+        done(`Initialized component project in workspace: ${bold(name)}`);
+        await createComponentFiles(name, componentDir, wsPath);
+        copyDefaultAssetsToPackage(componentDir);
+        modPkgJSon(componentDir, description);
+    } catch (err) {
+        failed(`Failed to generate component package: ${name}`, err);
+        cleanUp(componentDir);
+    }
+};
+const modPkgJSon = (componentDir, description) => {
+    const pkgJsonPath = join(componentDir, 'package.json');
+    const pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+    pkg.alpha = {
+        component: true,
+        description,
+    };
+    writeFileSync(pkgJsonPath, JSON.stringify(pkg, null, 2));
+};
+const createTs = (config) => {
+    const template = handlebars.compile(readFileSync(join(componentTemplatesPath(), '.component.ts.hbs'), 'utf-8'));
+    return template(config);
+};
+const createStyles = (config) => {
+    const template = handlebars.compile(readFileSync(join(componentTemplatesPath(), '.styles.ts.hbs'), 'utf-8'));
+    return template(config);
+};
+const createTest = (config) => {
+    const template = handlebars.compile(readFileSync(join(componentTemplatesPath(), '.test.ts.hbs'), 'utf-8'));
+    return template(config);
+};
+const appendToPublicAPIExports = (config) => {
+    const { componentSelector, componentDirName } = config;
+    return `export * from './packages/${componentDirName}/${componentSelector}';`;
+};
+const createComponentFiles = async (name, componentDirPath, wsPath) => {
+    const pluginJson = JSON.parse(readFileSync(join(wsPath, 'plugin.json'), 'utf-8'));
+    const componentSelector = getGeneratedComponentName(name);
+    const componentClassName = pascalCase(name);
+    const config = {
+        componentSelectorPrefix: pluginJson.components?.selectorPrefix || 'comp',
+        componentDirName: name,
+        componentSelector,
+        componentClassName,
+        componentDirPath,
+        componentLabel: sentenceCase(name),
+    };
+    mkdirSync(componentDirPath, { recursive: true });
+    await Promise.all([
+        writeFile(join(componentDirPath, `${componentSelector}.ts`), createTs(config), 'utf-8'),
+        writeFile(
+            join(componentDirPath, `${componentSelector}.styles.ts`),
+            await prettify(createStyles(config), 'typescript'),
+            'utf-8',
+        ),
+    ]);
+    const publicAPIPath = join(wsPath, './public-api.ts');
+    const publicAPIContent = readFileSync(publicAPIPath, 'utf-8');
+    const appendingContent = await prettify(appendToPublicAPIExports(config), 'typescript');
+    try {
+        await appendFile(publicAPIPath, appendingContent, 'utf-8');
+    } catch (err) {
+        failed(`Failed to update public-api.ts`, err);
+        writeFileSync(publicAPIPath, publicAPIContent);
+        throw err;
+    }
+};
+const cleanUp = (dir) => {
+    inprogress('Cleaning up...');
+    rmSync(dir, { recursive: true });
+    done('Cleaned up workspace');
+};

package/utils/generate-module.js ADDED Viewed

@@ -0,0 +1,51 @@
+//@ts-check
+import { kebabCase, pascalCase } from 'change-case';
+import { bold } from 'colorette';
+import handlebars from 'handlebars';
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { exit } from 'node:process';
+import { copyDefaultAssetsToPackage } from './copy-utils.js';
+import { done, failed, inprogress } from './logger.js';
+import { modulesTemplatesPath, pluginJsonPath } from './path-utils.js';
+import { prettify } from './prettify.js';
+export const generateModulePackageInWorkspace = async (wsPath, name, description) => {
+    const dir = join(wsPath, 'packages', name);
+    if (existsSync(dir)) {
+        failed(`Module ${dir} already exists`);
+        exit(1);
+    }
+    try {
+        inprogress(`Generating component package with name: ${bold(name)}`);
+        execSync(`npm init -y -w packages/${name}`);
+        modPkgJSon(dir, description);
+        await createModuleFiles(name, dir, wsPath);
+        copyDefaultAssetsToPackage(dir);
+        done(`Initialized module project in workspace: ${bold(name)}`);
+    } catch (err) {
+        failed(`Failed to generate module package: ${name}`, err);
+        rmSync(dir, { recursive: true });
+    }
+};
+const modPkgJSon = (dir, description) => {
+    const pkgJsonPath = join(dir, 'package.json');
+    const pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+    pkg.alpha = {
+        module: true,
+        description,
+    };
+    writeFileSync(pkgJsonPath, JSON.stringify(pkg, null, 2));
+};
+const createModuleFiles = async (name, moduleDirPath, wsPath) => {
+    const template = handlebars.compile(readFileSync(join(modulesTemplatesPath(), '.module.js.hbs'), 'utf-8'));
+    const pluginJson = JSON.parse(readFileSync(pluginJsonPath(wsPath), 'utf-8'));
+    const content = template({
+        pluginClassName: pascalCase(name),
+        pluginId: pluginJson.modules.idPrefix + kebabCase(name),
+    });
+    writeFileSync(join(moduleDirPath, 'index.js'), await prettify(content, 'typescript'));
+};

package/utils/get-package-info.js ADDED Viewed

@@ -0,0 +1,53 @@
+//@ts-check
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { getPackages } from './get-packages.js';
+import { inquiry } from './inquirer-utils.js';
+import { failed } from './logger.js';
+export const getPackageMetadata = async (wsPath, packageName, pkgType = '') => {
+    const packages = getPackages(wsPath);
+    if (!packages.length) {
+        failed('No packages found in the workspace');
+    }
+    let componentDirPath = '';
+    if (!packageName) {
+        const question = {
+            type: 'list',
+            name: 'value',
+            choices: packages
+                .map((p) => {
+                    const pkgJson = JSON.parse(readFileSync(join(p, 'package.json'), 'utf-8'));
+                    if (!pkgType || pkgJson.alpha[pkgType]) {
+                        return {
+                            name: `${p} (${pkgJson.name})`,
+                            value: {
+                                path: p,
+                                componentName: pkgJson.name,
+                            },
+                        };
+                    }
+                })
+                .filter(Boolean),
+            message: 'Choose the Package Name to Publish :',
+        };
+        const { componentName, path } = (await inquiry(question)).value;
+        packageName = componentName;
+        componentDirPath = path;
+    } else {
+        componentDirPath =
+            packages.find((v) => JSON.parse(readFileSync(join(v, 'package.json'), 'utf-8')).name === packageName) || '';
+    }
+    const componentExist = existsSync(componentDirPath);
+    if (!componentExist) {
+        throw new Error(packageName + " doesn't exist");
+    }
+    return {
+        packageName,
+        componentDirPath,
+    };
+};

package/utils/get-packages.js ADDED Viewed

@@ -0,0 +1,15 @@
+//@ts-check
+import { existsSync, globSync, readFileSync } from 'fs';
+import { join } from 'path';
+export const getPackages = (wsPath) => {
+    const packagesDir = JSON.parse(readFileSync(join(wsPath, 'package.json'), 'utf-8')).workspaces;
+    const packageNames = globSync(packagesDir, { cwd: wsPath });
+    return (
+        packageNames
+            .map((name) => join(wsPath, name))
+            .filter((p) => {
+                return existsSync(join(p, 'package.json'));
+            }) || []
+    );
+};