@qodalis/cli-core 0.0.1 → 0.0.3

package/esm2022/lib/constants/index.mjs

@@ -0,0 +1,8 @@
+export const DefaultLibraryAuthor = {
+    name: 'Nicolae Lupei',
+    email: 'nicolae.lupei@qodalis.com',
+};
+export const constants = {
+    DefaultLibraryAuthor,
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb3JlL3NyYy9saWIvY29uc3RhbnRzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sQ0FBQyxNQUFNLG9CQUFvQixHQUFzQjtJQUNuRCxJQUFJLEVBQUUsZUFBZTtJQUNyQixLQUFLLEVBQUUsMkJBQTJCO0NBQ3JDLENBQUM7QUFFRixNQUFNLENBQUMsTUFBTSxTQUFTLEdBQUc7SUFDckIsb0JBQW9CO0NBQ3ZCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJQ2xpQ29tbWFuZEF1dGhvciB9IGZyb20gJy4uL2ludGVyZmFjZXMnO1xuXG5leHBvcnQgY29uc3QgRGVmYXVsdExpYnJhcnlBdXRob3I6IElDbGlDb21tYW5kQXV0aG9yID0ge1xuICAgIG5hbWU6ICdOaWNvbGFlIEx1cGVpJyxcbiAgICBlbWFpbDogJ25pY29sYWUubHVwZWlAcW9kYWxpcy5jb20nLFxufTtcblxuZXhwb3J0IGNvbnN0IGNvbnN0YW50cyA9IHtcbiAgICBEZWZhdWx0TGlicmFyeUF1dGhvcixcbn07XG4iXX0=

package/esm2022/lib/interfaces/index.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../projects/core/src/lib/interfaces/index.ts"],"names":[],"mappings":"","sourcesContent":["import { Terminal } from '@xterm/xterm';\nimport { Observable, Subject } from 'rxjs';\nimport {\n    CliBackgroundColor,\n    CliForegroundColor,\n    CliOptions,\n    CliProcessCommand,\n    ICliUser,\n    ICliUserSession,\n} from '../models';\n\nexport interface ICliCommandAuthor {\n    /**\n     * The name of the author\n     */\n    name: string;\n\n    /**\n     * The email of the author\n     */\n    email: string;\n}\n\n/**\n * Represents a command processor\n */\nexport interface ICliCommandProcessor {\n    /**\n     * The command that this processor handles\n     */\n    command: string;\n\n    /**\n     * A description of the command\n     */\n    description?: string;\n\n    /**\n     * The author of the command\n     */\n    author?: ICliCommandAuthor;\n\n    /**\n     * If true, the processor can handle unlisted commands\n     */\n    allowUnlistedCommands?: boolean;\n\n    /**\n     * If true, the value is required\n     */\n    valueRequired?: boolean;\n\n    /**\n     * The version of the command processor\n     * @default '1.0.0'\n     */\n    version?: string;\n\n    /**\n     * Processors that are nested under this processor\n     */\n    processors?: ICliCommandProcessor[];\n\n    /**\n     * Parameters that the command accepts\n     */\n    parameters?: ICliCommandParameterDescriptor[];\n\n    /**\n     * Process the command\n     * @param command The command to process\n     * @param context The context in which the command is executed\n     */\n    processCommand(\n        command: CliProcessCommand,\n        context: ICliExecutionContext,\n    ): Promise<void>;\n\n    /**\n     * Write the description of the command\n     * @param context The context in which the command is executed\n     */\n    writeDescription?(context: ICliExecutionContext): void;\n\n    /**\n     * A function that validates the command before execution\n     * @param value The value to validate\n     * @returns An object with a valid property that indicates if the value is valid and an optional message property that contains a message to display if the value is not valid\n     */\n    validateBeforeExecution?: (\n        command: CliProcessCommand,\n        context: ICliExecutionContext,\n    ) => {\n        valid: boolean;\n        message?: string;\n    };\n\n    /**\n     * Initialize the command processor\n     * @param context The context in which the command is executed\n     */\n    initialize?(context: ICliExecutionContext): Promise<void>;\n}\n\n/**\n * Represents a command parameter\n */\nexport interface ICliCommandParameterDescriptor {\n    /**\n     * The name of the parameter\n     */\n    name: string;\n\n    /**\n     * Aliases for the parameter\n     */\n    aliases?: string[];\n\n    /**\n     * A description of the parameter\n     */\n    description: string;\n\n    /**\n     * If true, the parameter is required\n     */\n    required: boolean;\n\n    /**\n     * The type of the parameter\n     */\n    type: string;\n\n    /**\n     * The default value of the parameter\n     */\n    defaultValue?: any;\n\n    /**\n     * A validator function that validates the value of the parameter\n     * @param value The value to validate\n     * @returns An object with a valid property that indicates if the value is valid and an optional message property that contains a message to display if the value is not valid\n     */\n    validator?: (value: any) => {\n        /**\n         * Indicates if the value is valid\n         */\n        valid: boolean;\n\n        /**\n         * An optional message to display if the value is not valid\n         */\n        message?: string;\n    };\n}\n\nexport interface ICliTerminalWriter {\n    /**\n     * Write text to the terminal\n     * @param text The text to write\n     */\n    write(text: string): void;\n\n    /**\n     * Write text to the terminal followed by a newline\n     * @param text The text to write\n     */\n    writeln(text: string): void;\n\n    /**\n     * Write a success message to the terminal\n     * @param messag The message to write\n     * @returns void\n     */\n    writeSuccess: (message: string) => void;\n\n    /**\n     * Write an info message to the terminal\n     * @param messag The message to write\n     * @returns void\n     */\n    writeInfo: (message: string) => void;\n\n    /**\n     * Write an error message to the terminal\n     * @param message The message to write\n     * @returns void\n     */\n    writeError: (message: string) => void;\n\n    /**\n     * Write a warning message to the terminal\n     * @param message The message to write\n     * @returns void\n     */\n    writeWarning: (message: string) => void;\n\n    /**\n     * Write a message to the terminal with the specified color\n     * @param message The message to write\n     * @param color The color to use\n     * @returns void\n     */\n    wrapInColor: (text: string, color: CliForegroundColor) => string;\n\n    /**\n     * Write a message to the terminal with the specified background color\n     * @param message The message to write\n     * @param color The background color to use\n     * @returns void\n     */\n    wrapInBackgroundColor: (text: string, color: CliBackgroundColor) => string;\n\n    /**\n     * Write a JSON object to the terminal\n     * @param json The JSON object to write\n     * @returns void\n     */\n    writeJson: (json: any) => void;\n\n    /**\n     * Write content to a file\n     * @param fileName The name of the file to write to\n     * @param content The content to write to the file\n     * @returns void\n     */\n    writeToFile: (fileName: string, content: string) => void;\n\n    /**\n     * Write an object array as a table to the terminal\n     * @param objects The objects to write to the table\n     * @returns void\n     */\n    writeObjectArrayTable(objects: any[]): void;\n\n    /**\n     * Write a table to the terminal\n     * @param headers The headers of the table\n     * @param rows The rows of the table\n     * @returns void\n     */\n    writeTable(headers: string[], rows: string[][]): void;\n}\n\nexport interface ICliProgressBar {\n    /**\n     * Indicates if the progress bar is running\n     */\n    isRunning: boolean;\n\n    /**\n     * Show the progress bar\n     */\n    show: () => void;\n\n    /**\n     * Hide the progress bar\n     */\n    hide: () => void;\n}\n\n/**\n * Represents a spinner for the CLI\n */\nexport interface ICliSpinner extends ICliProgressBar {}\n\n/**\n * Represents a progress bar for the CLI\n */\nexport interface ICliPercentageProgressBar extends ICliProgressBar {\n    /**\n     * Update the progress of the progress bar\n     * @param progress The progress to update to\n     * @returns void\n     */\n    update: (progress: number) => void;\n\n    /**\n     * Complete the progress bar\n     * @returns void\n     */\n    complete: () => void;\n}\n\n/**\n * Represents a clipboard for the CLI\n */\nexport interface ICliClipboard {\n    /**\n     * Write text to the clipboard\n     * @param text The text to write to the clipboard\n     * @returns void\n     */\n    write: (text: string) => Promise<void>;\n\n    /**\n     * Read text from the clipboard\n     * @returns The text read from the clipboard\n     */\n    read: () => Promise<string>;\n}\n\n/**\n * Represents a service that executes commands\n */\nexport interface ICliCommandExecutorService {\n    /**\n     *\n     * @param command\n     * @param context\n     */\n    showHelp(\n        command: CliProcessCommand,\n        context: ICliExecutionContext,\n    ): Promise<void>;\n\n    /**\n     * List all commands\n     * @returns An array of all commands\n     */\n    listCommands(): string[];\n\n    /**\n     * Find a processor for a command\n     * @param mainCommand\n     * @param chainCommands\n     */\n    findProcessor(\n        mainCommand: string,\n        chainCommands: string[],\n    ): ICliCommandProcessor | undefined;\n}\n\n/**\n * Represents the context in which a command is executed\n */\nexport interface ICliExecutionContext {\n    /**\n     * The current user session\n     */\n    userSession?: ICliUserSession;\n\n    /**\n     * The spinner to use for showing/hiding the loader\n     */\n    spinner?: ICliSpinner;\n\n    /**\n     * The progress bar to use for showing progress\n     */\n    progressBar: ICliPercentageProgressBar;\n\n    /**\n     * A subject that emits when the command is aborted\n     */\n    onAbort: Subject<void>;\n\n    /**\n     * The terminal to use for writing\n     */\n    terminal: Terminal;\n\n    /**\n     * The writer to use for writing to the terminal\n     */\n    writer: ICliTerminalWriter;\n\n    /**\n     * The command executor to use for executing commands\n     */\n    executor: ICliCommandExecutorService;\n\n    /**\n     * The clipboard to use for copying/pasting\n     */\n    clipboard: ICliClipboard;\n\n    /**\n     * The data store to use for storing data\n     */\n    dataStore: ICliCommandDataStore;\n\n    /**\n     * The options for the CLI\n     */\n    options?: CliOptions;\n\n    /**\n     * The prompt to use for prompting the user for input\n     */\n    showPrompt: () => void;\n}\n\n/**\n * Represents a data store for storing data associated with commands\n */\nexport interface ICliCommandDataStore {\n    /**\n     * The data store\n     */\n    data: Record<string, Record<string, any>>;\n\n    /**\n     * Append data to the data store\n     * @param command\n     * @param key\n     * @param data\n     */\n    appendData(command: string, key: string, data: any): void;\n\n    /**\n     * Get data from the data store\n     * @param command\n     * @param key\n     */\n    getData<T = any>(command: string, key: string): T;\n}\n\n/**\n * Represents a service that manages user sessions in the CLI\n */\nexport interface ICliUserSessionService {\n    /**\n     * Gets the current user session\n     * @returns An observable that emits the current user session\n     */\n    getUserSession(): Observable<ICliUserSession | undefined>;\n\n    /**\n     * Sets the current user session\n     * @param session The session to set\n     */\n    setUserSession(session: ICliUserSession): Promise<void>;\n}\n\n/**\n * Represents a service that manages users in the CLI\n */\nexport interface ICliUsersStoreService {\n    /**\n     * Gets the current users\n     * @returns An observable that emits the current users\n     */\n    getUsers(): Observable<ICliUser[]>;\n\n    /**\n     * Sets the current users\n     * @param users The users to set\n     */\n    setUsers(users: ICliUser[]): Promise<void>;\n\n    /**\n     * Gets a user by id\n     * @param id The id of the user to get\n     * @returns An observable that emits the user with the specified id\n     */\n    getUser(id: string): Observable<ICliUser | undefined>;\n}\n\n/**\n * Represents a service that pings the server\n */\nexport interface ICliPingServerService {\n    /**\n     * Pings the server\n     */\n    ping(): Promise<void>;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../projects/core/src/lib/interfaces/index.ts"],"names":[],"mappings":"","sourcesContent":["import { Terminal } from '@xterm/xterm';\nimport { Observable, Subject } from 'rxjs';\nimport {\n    CliBackgroundColor,\n    CliForegroundColor,\n    CliOptions,\n    CliProcessCommand,\n    ICliUser,\n    ICliUserSession,\n    Package,\n} from '../models';\n\nexport interface ICliCommandAuthor {\n    /**\n     * The name of the author\n     */\n    name: string;\n\n    /**\n     * The email of the author\n     */\n    email: string;\n}\n\n/**\n * Represents a command processor\n */\nexport interface ICliCommandProcessor {\n    /**\n     * The command that this processor handles\n     */\n    command: string;\n\n    /**\n     * A description of the command\n     */\n    description?: string;\n\n    /**\n     * The author of the command\n     */\n    author?: ICliCommandAuthor;\n\n    /**\n     * If true, the processor can handle unlisted commands\n     */\n    allowUnlistedCommands?: boolean;\n\n    /**\n     * If true, the value is required\n     */\n    valueRequired?: boolean;\n\n    /**\n     * The version of the command processor\n     * @default '1.0.0'\n     */\n    version?: string;\n\n    /**\n     * Processors that are nested under this processor\n     */\n    processors?: ICliCommandProcessor[];\n\n    /**\n     * Parameters that the command accepts\n     */\n    parameters?: ICliCommandParameterDescriptor[];\n\n    /**\n     * Process the command\n     * @param command The command to process\n     * @param context The context in which the command is executed\n     */\n    processCommand(\n        command: CliProcessCommand,\n        context: ICliExecutionContext,\n    ): Promise<void>;\n\n    /**\n     * Write the description of the command\n     * @param context The context in which the command is executed\n     */\n    writeDescription?(context: ICliExecutionContext): void;\n\n    /**\n     * A function that validates the command before execution\n     * @param value The value to validate\n     * @returns An object with a valid property that indicates if the value is valid and an optional message property that contains a message to display if the value is not valid\n     */\n    validateBeforeExecution?: (\n        command: CliProcessCommand,\n        context: ICliExecutionContext,\n    ) => {\n        valid: boolean;\n        message?: string;\n    };\n\n    /**\n     * Initialize the command processor\n     * @param context The context in which the command is executed\n     */\n    initialize?(context: ICliExecutionContext): Promise<void>;\n}\n\n/**\n * Represents a command parameter\n */\nexport interface ICliCommandParameterDescriptor {\n    /**\n     * The name of the parameter\n     */\n    name: string;\n\n    /**\n     * Aliases for the parameter\n     */\n    aliases?: string[];\n\n    /**\n     * A description of the parameter\n     */\n    description: string;\n\n    /**\n     * If true, the parameter is required\n     */\n    required: boolean;\n\n    /**\n     * The type of the parameter\n     */\n    type: string;\n\n    /**\n     * The default value of the parameter\n     */\n    defaultValue?: any;\n\n    /**\n     * A validator function that validates the value of the parameter\n     * @param value The value to validate\n     * @returns An object with a valid property that indicates if the value is valid and an optional message property that contains a message to display if the value is not valid\n     */\n    validator?: (value: any) => {\n        /**\n         * Indicates if the value is valid\n         */\n        valid: boolean;\n\n        /**\n         * An optional message to display if the value is not valid\n         */\n        message?: string;\n    };\n}\n\nexport interface ICliTerminalWriter {\n    /**\n     * Write text to the terminal\n     * @param text The text to write\n     */\n    write(text: string): void;\n\n    /**\n     * Write text to the terminal followed by a newline\n     * @param text The text to write\n     */\n    writeln(text: string): void;\n\n    /**\n     * Write a success message to the terminal\n     * @param messag The message to write\n     * @returns void\n     */\n    writeSuccess: (message: string) => void;\n\n    /**\n     * Write an info message to the terminal\n     * @param messag The message to write\n     * @returns void\n     */\n    writeInfo: (message: string) => void;\n\n    /**\n     * Write an error message to the terminal\n     * @param message The message to write\n     * @returns void\n     */\n    writeError: (message: string) => void;\n\n    /**\n     * Write a warning message to the terminal\n     * @param message The message to write\n     * @returns void\n     */\n    writeWarning: (message: string) => void;\n\n    /**\n     * Write a message to the terminal with the specified color\n     * @param message The message to write\n     * @param color The color to use\n     * @returns void\n     */\n    wrapInColor: (text: string, color: CliForegroundColor) => string;\n\n    /**\n     * Write a message to the terminal with the specified background color\n     * @param message The message to write\n     * @param color The background color to use\n     * @returns void\n     */\n    wrapInBackgroundColor: (text: string, color: CliBackgroundColor) => string;\n\n    /**\n     * Write a JSON object to the terminal\n     * @param json The JSON object to write\n     * @returns void\n     */\n    writeJson: (json: any) => void;\n\n    /**\n     * Write content to a file\n     * @param fileName The name of the file to write to\n     * @param content The content to write to the file\n     * @returns void\n     */\n    writeToFile: (fileName: string, content: string) => void;\n\n    /**\n     * Write an object array as a table to the terminal\n     * @param objects The objects to write to the table\n     * @returns void\n     */\n    writeObjectArrayTable(objects: any[]): void;\n\n    /**\n     * Write a table to the terminal\n     * @param headers The headers of the table\n     * @param rows The rows of the table\n     * @returns void\n     */\n    writeTable(headers: string[], rows: string[][]): void;\n}\n\nexport interface ICliProgressBar {\n    /**\n     * Indicates if the progress bar is running\n     */\n    isRunning: boolean;\n\n    /**\n     * Show the progress bar\n     */\n    show: () => void;\n\n    /**\n     * Hide the progress bar\n     */\n    hide: () => void;\n}\n\n/**\n * Represents a spinner for the CLI\n */\nexport interface ICliSpinner extends ICliProgressBar {}\n\n/**\n * Represents a progress bar for the CLI\n */\nexport interface ICliPercentageProgressBar extends ICliProgressBar {\n    /**\n     * Update the progress of the progress bar\n     * @param progress The progress to update to\n     * @returns void\n     */\n    update: (progress: number) => void;\n\n    /**\n     * Complete the progress bar\n     * @returns void\n     */\n    complete: () => void;\n}\n\n/**\n * Represents a clipboard for the CLI\n */\nexport interface ICliClipboard {\n    /**\n     * Write text to the clipboard\n     * @param text The text to write to the clipboard\n     * @returns void\n     */\n    write: (text: string) => Promise<void>;\n\n    /**\n     * Read text from the clipboard\n     * @returns The text read from the clipboard\n     */\n    read: () => Promise<string>;\n}\n\n/**\n * Represents a service that executes commands\n */\nexport interface ICliCommandExecutorService {\n    /**\n     *\n     * @param command\n     * @param context\n     */\n    showHelp(\n        command: CliProcessCommand,\n        context: ICliExecutionContext,\n    ): Promise<void>;\n\n    /**\n     * List all commands\n     * @returns An array of all commands\n     */\n    listCommands(): string[];\n\n    /**\n     * Find a processor for a command\n     * @param mainCommand\n     * @param chainCommands\n     */\n    findProcessor(\n        mainCommand: string,\n        chainCommands: string[],\n    ): ICliCommandProcessor | undefined;\n\n    /**\n     * Register a processor\n     * @param processor\n     */\n    registerProcessor(processor: ICliCommandProcessor): void;\n}\n\n/**\n * Represents the context in which a command is executed\n */\nexport interface ICliExecutionContext {\n    /**\n     * The current user session\n     */\n    userSession?: ICliUserSession;\n\n    /**\n     * The spinner to use for showing/hiding the loader\n     */\n    spinner?: ICliSpinner;\n\n    /**\n     * The progress bar to use for showing progress\n     */\n    progressBar: ICliPercentageProgressBar;\n\n    /**\n     * A subject that emits when the command is aborted\n     */\n    onAbort: Subject<void>;\n\n    /**\n     * The terminal to use for writing\n     */\n    terminal: Terminal;\n\n    /**\n     * The writer to use for writing to the terminal\n     */\n    writer: ICliTerminalWriter;\n\n    /**\n     * The command executor to use for executing commands\n     */\n    executor: ICliCommandExecutorService;\n\n    /**\n     * The clipboard to use for copying/pasting\n     */\n    clipboard: ICliClipboard;\n\n    /**\n     * The data store to use for storing data\n     */\n    dataStore: ICliCommandDataStore;\n\n    /**\n     * The options for the CLI\n     */\n    options?: CliOptions;\n\n    /**\n     * The prompt to use for prompting the user for input\n     */\n    showPrompt: () => void;\n}\n\n/**\n * Represents a data store for storing data associated with commands\n */\nexport interface ICliCommandDataStore {\n    /**\n     * The data store\n     */\n    data: Record<string, Record<string, any>>;\n\n    /**\n     * Append data to the data store\n     * @param command\n     * @param key\n     * @param data\n     */\n    appendData(command: string, key: string, data: any): void;\n\n    /**\n     * Get data from the data store\n     * @param command\n     * @param key\n     */\n    getData<T = any>(command: string, key: string): T;\n}\n\n/**\n * Represents a service that manages user sessions in the CLI\n */\nexport interface ICliUserSessionService {\n    /**\n     * Gets the current user session\n     * @returns An observable that emits the current user session\n     */\n    getUserSession(): Observable<ICliUserSession | undefined>;\n\n    /**\n     * Sets the current user session\n     * @param session The session to set\n     */\n    setUserSession(session: ICliUserSession): Promise<void>;\n}\n\n/**\n * Represents a service that manages users in the CLI\n */\nexport interface ICliUsersStoreService {\n    /**\n     * Gets the current users\n     * @returns An observable that emits the current users\n     */\n    getUsers(): Observable<ICliUser[]>;\n\n    /**\n     * Sets the current users\n     * @param users The users to set\n     */\n    setUsers(users: ICliUser[]): Promise<void>;\n\n    /**\n     * Gets a user by id\n     * @param id The id of the user to get\n     * @returns An observable that emits the user with the specified id\n     */\n    getUser(id: string): Observable<ICliUser | undefined>;\n}\n\n/**\n * Represents a service that pings the server\n */\nexport interface ICliPingServerService {\n    /**\n     * Pings the server\n     */\n    ping(): Promise<void>;\n}\n\n/**\n * Represents a module for the CLI\n */\nexport interface ICliUmdModule {\n    /**\n     * The name of the module\n     */\n    name: string;\n\n    /**\n     * The processors for the module\n     */\n    processors: ICliCommandProcessor[];\n\n    /**\n     * The dependencies for the module\n     */\n    dependencies?: Package[];\n}\n"]}

package/esm2022/lib/models/index.mjs

@@ -21,4 +21,4 @@ export var CliBackgroundColor;
     CliBackgroundColor["Cyan"] = "\u001B[46m";
     CliBackgroundColor["White"] = "\u001B[47m";
 })(CliBackgroundColor || (CliBackgroundColor = {}));
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/modules/index.mjs

@@ -0,0 +1,23 @@
+import { constants } from '../constants';
+import { utils } from '../utils';
+export const initializeBrowserEnvironment = ({ handlers, }) => {
+    window.core = {
+        onUmdModuleBoot: handlers || [],
+        bootUmdModule: async (module) => {
+            handlers.forEach(async (handler) => await handler(module));
+        },
+        Injectable: () => ({}),
+        ...constants,
+        ...utils,
+    };
+};
+export const bootUmdModule = async (module) => {
+    if (typeof window !== 'undefined') {
+        window[module.name] = module;
+        await window.core.bootUmdModule(module);
+    }
+    else {
+        console.log('window is undefined');
+    }
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/utils/index.mjs

@@ -0,0 +1,57 @@
+import { CliBackgroundColor, CliForegroundColor } from '../models';
+export const getParameterValue = (p, args) => {
+    return (args[p.name] ??
+        (p.aliases?.find((alias) => args[alias]) &&
+            args[p.aliases.find((alias) => args[alias])]));
+};
+export const formatJson = (json) => {
+    const identedJson = JSON.stringify(json, null, 2);
+    return colorizeJson(identedJson.split('\n').join('\r\n'));
+};
+export const colorizeJson = (jsonString) => {
+    return jsonString
+        .replace(/"([^"]+)":/g, '\x1b[33m"$1":\x1b[0m') // Keys (yellow)
+        .replace(/: "([^"]*)"/g, ': \x1b[32m"$1"\x1b[0m') // Strings (green)
+        .replace(/: (\d+)/g, ': \x1b[34m$1\x1b[0m') // Numbers (blue)
+        .replace(/: (true|false)/g, ': \x1b[35m$1\x1b[0m') // Booleans (magenta)
+        .replace(/: (null)/g, ': \x1b[36m$1\x1b[0m'); // Null (cyan)
+};
+export const toQueryString = (params) => {
+    const searchParams = new URLSearchParams();
+    for (const key in params) {
+        if (params.hasOwnProperty(key)) {
+            const value = params[key];
+            // Handle array and non-primitive values
+            if (Array.isArray(value)) {
+                value.forEach((v) => searchParams.append(key, v.toString()));
+            }
+            else if (value !== null && value !== undefined) {
+                searchParams.append(key, value.toString());
+            }
+        }
+    }
+    return searchParams.toString();
+};
+export const highlightTextWithBg = (text, pattern, bgColor = CliBackgroundColor.Yellow) => {
+    // Replace matches with background-colored text
+    return text.replace(pattern, (match) => `${bgColor}${match}${CliForegroundColor.Reset}`);
+};
+export const getRightOfWord = (command, word) => {
+    // Find the position of the word in the command
+    const index = command.indexOf(word);
+    // If the word is found, extract the substring to the right
+    if (index !== -1) {
+        return command.slice(index + word.length).trim();
+    }
+    // If the word is not found, return null
+    return undefined;
+};
+export const utils = {
+    getParameterValue,
+    formatJson,
+    colorizeJson,
+    toQueryString,
+    highlightTextWithBg,
+    getRightOfWord,
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/public-api.mjs

@@ -3,4 +3,7 @@
  */
 export * from './lib/models';
 export * from './lib/interfaces';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2NvcmUvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQztBQUU3QixjQUFjLGtCQUFrQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBjb3JlXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9saWIvbW9kZWxzJztcblxuZXhwb3J0ICogZnJvbSAnLi9saWIvaW50ZXJmYWNlcyc7XG4iXX0=
+export * from './lib/modules';
+export * from './lib/utils';
+export * from './lib/constants';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2NvcmUvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQztBQUU3QixjQUFjLGtCQUFrQixDQUFDO0FBRWpDLGNBQWMsZUFBZSxDQUFDO0FBRTlCLGNBQWMsYUFBYSxDQUFDO0FBRTVCLGNBQWMsaUJBQWlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIGNvcmVcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2xpYi9tb2RlbHMnO1xuXG5leHBvcnQgKiBmcm9tICcuL2xpYi9pbnRlcmZhY2VzJztcblxuZXhwb3J0ICogZnJvbSAnLi9saWIvbW9kdWxlcyc7XG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL3V0aWxzJztcblxuZXhwb3J0ICogZnJvbSAnLi9saWIvY29uc3RhbnRzJztcbiJdfQ==

package/fesm2022/qodalis-cli-core.mjs

@@ -22,6 +22,91 @@ var CliBackgroundColor;
     CliBackgroundColor["White"] = "\u001B[47m";
 })(CliBackgroundColor || (CliBackgroundColor = {}));
 
+const DefaultLibraryAuthor = {
+    name: 'Nicolae Lupei',
+    email: 'nicolae.lupei@qodalis.com',
+};
+const constants = {
+    DefaultLibraryAuthor,
+};
+
+const getParameterValue = (p, args) => {
+    return (args[p.name] ??
+        (p.aliases?.find((alias) => args[alias]) &&
+            args[p.aliases.find((alias) => args[alias])]));
+};
+const formatJson = (json) => {
+    const identedJson = JSON.stringify(json, null, 2);
+    return colorizeJson(identedJson.split('\n').join('\r\n'));
+};
+const colorizeJson = (jsonString) => {
+    return jsonString
+        .replace(/"([^"]+)":/g, '\x1b[33m"$1":\x1b[0m') // Keys (yellow)
+        .replace(/: "([^"]*)"/g, ': \x1b[32m"$1"\x1b[0m') // Strings (green)
+        .replace(/: (\d+)/g, ': \x1b[34m$1\x1b[0m') // Numbers (blue)
+        .replace(/: (true|false)/g, ': \x1b[35m$1\x1b[0m') // Booleans (magenta)
+        .replace(/: (null)/g, ': \x1b[36m$1\x1b[0m'); // Null (cyan)
+};
+const toQueryString = (params) => {
+    const searchParams = new URLSearchParams();
+    for (const key in params) {
+        if (params.hasOwnProperty(key)) {
+            const value = params[key];
+            // Handle array and non-primitive values
+            if (Array.isArray(value)) {
+                value.forEach((v) => searchParams.append(key, v.toString()));
+            }
+            else if (value !== null && value !== undefined) {
+                searchParams.append(key, value.toString());
+            }
+        }
+    }
+    return searchParams.toString();
+};
+const highlightTextWithBg = (text, pattern, bgColor = CliBackgroundColor.Yellow) => {
+    // Replace matches with background-colored text
+    return text.replace(pattern, (match) => `${bgColor}${match}${CliForegroundColor.Reset}`);
+};
+const getRightOfWord = (command, word) => {
+    // Find the position of the word in the command
+    const index = command.indexOf(word);
+    // If the word is found, extract the substring to the right
+    if (index !== -1) {
+        return command.slice(index + word.length).trim();
+    }
+    // If the word is not found, return null
+    return undefined;
+};
+const utils = {
+    getParameterValue,
+    formatJson,
+    colorizeJson,
+    toQueryString,
+    highlightTextWithBg,
+    getRightOfWord,
+};
+
+const initializeBrowserEnvironment = ({ handlers, }) => {
+    window.core = {
+        onUmdModuleBoot: handlers || [],
+        bootUmdModule: async (module) => {
+            handlers.forEach(async (handler) => await handler(module));
+        },
+        Injectable: () => ({}),
+        ...constants,
+        ...utils,
+    };
+};
+const bootUmdModule = async (module) => {
+    if (typeof window !== 'undefined') {
+        window[module.name] = module;
+        await window.core.bootUmdModule(module);
+    }
+    else {
+        console.log('window is undefined');
+    }
+};
+
 /*
  * Public API Surface of core
  */
@@ -30,5 +115,5 @@ var CliBackgroundColor;
  * Generated bundle index. Do not edit.
  */
 
-export { CliBackgroundColor, CliForegroundColor };
+export { CliBackgroundColor, CliForegroundColor, DefaultLibraryAuthor, bootUmdModule, colorizeJson, constants, formatJson, getParameterValue, getRightOfWord, highlightTextWithBg, initializeBrowserEnvironment, toQueryString, utils };
 //# sourceMappingURL=qodalis-cli-core.mjs.map

package/fesm2022/qodalis-cli-core.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"qodalis-cli-core.mjs","sources":["../../../projects/core/src/lib/models/index.ts","../../../projects/core/src/public-api.ts","../../../projects/core/src/qodalis-cli-core.ts"],"sourcesContent":["import { ITerminalInitOnlyOptions, ITerminalOptions } from '@xterm/xterm';\n\nexport type CliProcessCommand = {\n    /**\n     * The command that was entered\n     */\n    command: string;\n\n    /**\n     * The chain of commands that were entered\n     */\n    chainCommands: string[];\n\n    /**\n     * The raw command that was entered\n     */\n    rawCommand: string;\n\n    /**\n     * The value of the command\n     */\n    value?: string;\n\n    /**\n     * The arguments that were entered\n     */\n    args: Record<string, any>;\n};\n\nexport enum CliForegroundColor {\n    Black = '\\x1b[30m',\n    Red = '\\x1b[31m',\n    Green = '\\x1b[32m',\n    Yellow = '\\x1b[33m',\n    Blue = '\\x1b[34m',\n    Magenta = '\\x1b[35m',\n    Cyan = '\\x1b[36m',\n    White = '\\x1b[37m',\n    Reset = '\\x1b[0m',\n}\n\nexport enum CliBackgroundColor {\n    Black = '\\x1b[40m',\n    Red = '\\x1b[41m',\n    Green = '\\x1b[42m',\n    Yellow = '\\x1b[43m',\n    Blue = '\\x1b[44m',\n    Magenta = '\\x1b[45m',\n    Cyan = '\\x1b[46m',\n    White = '\\x1b[47m',\n}\n\nexport interface ICliUser extends Record<string, any> {\n    /**\n     * The id of the user\n     */\n    id: string;\n\n    /**\n     * The name of the user\n     */\n    name: string;\n\n    /**\n     * The email of the user\n     */\n    email: string;\n}\n\nexport interface ICliUserSession {\n    /**\n     * The user associated with the session\n     */\n    user: ICliUser;\n\n    /**\n     * The data associated with the user session\n     */\n    data?: Record<string, any>;\n}\n\n/**\n * Options for the CLI\n */\nexport type CliOptions = {\n    /**\n     * The welcome message to display when the CLI starts\n     */\n    welcomeMessage?: string;\n\n    /**\n     * Hide the prompt to display when the CLI is ready to accept input\n     */\n    hideUserName?: boolean;\n\n    /**\n     * Custom terminal options\n     */\n    terminalOptions?: ITerminalOptions & ITerminalInitOnlyOptions;\n};\n","/*\n * Public API Surface of core\n */\n\nexport * from './lib/models';\n\nexport * from './lib/interfaces';\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n"],"names":[],"mappings":"IA6BY,mBAUX;AAVD,CAAA,UAAY,kBAAkB,EAAA;AAC1B,IAAA,kBAAA,CAAA,OAAA,CAAA,GAAA,YAAkB,CAAA;AAClB,IAAA,kBAAA,CAAA,KAAA,CAAA,GAAA,YAAgB,CAAA;AAChB,IAAA,kBAAA,CAAA,OAAA,CAAA,GAAA,YAAkB,CAAA;AAClB,IAAA,kBAAA,CAAA,QAAA,CAAA,GAAA,YAAmB,CAAA;AACnB,IAAA,kBAAA,CAAA,MAAA,CAAA,GAAA,YAAiB,CAAA;AACjB,IAAA,kBAAA,CAAA,SAAA,CAAA,GAAA,YAAoB,CAAA;AACpB,IAAA,kBAAA,CAAA,MAAA,CAAA,GAAA,YAAiB,CAAA;AACjB,IAAA,kBAAA,CAAA,OAAA,CAAA,GAAA,YAAkB,CAAA;AAClB,IAAA,kBAAA,CAAA,OAAA,CAAA,GAAA,WAAiB,CAAA;AACrB,CAAC,EAVW,kBAAkB,KAAlB,kBAAkB,GAU7B,EAAA,CAAA,CAAA,CAAA;IAEW,mBASX;AATD,CAAA,UAAY,kBAAkB,EAAA;AAC1B,IAAA,kBAAA,CAAA,OAAA,CAAA,GAAA,YAAkB,CAAA;AAClB,IAAA,kBAAA,CAAA,KAAA,CAAA,GAAA,YAAgB,CAAA;AAChB,IAAA,kBAAA,CAAA,OAAA,CAAA,GAAA,YAAkB,CAAA;AAClB,IAAA,kBAAA,CAAA,QAAA,CAAA,GAAA,YAAmB,CAAA;AACnB,IAAA,kBAAA,CAAA,MAAA,CAAA,GAAA,YAAiB,CAAA;AACjB,IAAA,kBAAA,CAAA,SAAA,CAAA,GAAA,YAAoB,CAAA;AACpB,IAAA,kBAAA,CAAA,MAAA,CAAA,GAAA,YAAiB,CAAA;AACjB,IAAA,kBAAA,CAAA,OAAA,CAAA,GAAA,YAAkB,CAAA;AACtB,CAAC,EATW,kBAAkB,KAAlB,kBAAkB,GAS7B,EAAA,CAAA,CAAA;;AClDD;;AAEG;;ACFH;;AAEG;;;;"}
+{"version":3,"file":"qodalis-cli-core.mjs","sources":["../../../projects/core/src/lib/models/index.ts","../../../projects/core/src/lib/constants/index.ts","../../../projects/core/src/lib/utils/index.ts","../../../projects/core/src/lib/modules/index.ts","../../../projects/core/src/public-api.ts","../../../projects/core/src/qodalis-cli-core.ts"],"sourcesContent":["import { ITerminalInitOnlyOptions, ITerminalOptions } from '@xterm/xterm';\n\nexport type CliProcessCommand = {\n    /**\n     * The command that was entered\n     */\n    command: string;\n\n    /**\n     * The chain of commands that were entered\n     */\n    chainCommands: string[];\n\n    /**\n     * The raw command that was entered\n     */\n    rawCommand: string;\n\n    /**\n     * The value of the command\n     */\n    value?: string;\n\n    /**\n     * The arguments that were entered\n     */\n    args: Record<string, any>;\n};\n\nexport enum CliForegroundColor {\n    Black = '\\x1b[30m',\n    Red = '\\x1b[31m',\n    Green = '\\x1b[32m',\n    Yellow = '\\x1b[33m',\n    Blue = '\\x1b[34m',\n    Magenta = '\\x1b[35m',\n    Cyan = '\\x1b[36m',\n    White = '\\x1b[37m',\n    Reset = '\\x1b[0m',\n}\n\nexport enum CliBackgroundColor {\n    Black = '\\x1b[40m',\n    Red = '\\x1b[41m',\n    Green = '\\x1b[42m',\n    Yellow = '\\x1b[43m',\n    Blue = '\\x1b[44m',\n    Magenta = '\\x1b[45m',\n    Cyan = '\\x1b[46m',\n    White = '\\x1b[47m',\n}\n\nexport interface ICliUser extends Record<string, any> {\n    /**\n     * The id of the user\n     */\n    id: string;\n\n    /**\n     * The name of the user\n     */\n    name: string;\n\n    /**\n     * The email of the user\n     */\n    email: string;\n}\n\nexport interface ICliUserSession {\n    /**\n     * The user associated with the session\n     */\n    user: ICliUser;\n\n    /**\n     * The data associated with the user session\n     */\n    data?: Record<string, any>;\n}\n\n/**\n * Options for the CLI\n */\nexport type CliOptions = {\n    /**\n     * The welcome message to display when the CLI starts\n     */\n    welcomeMessage?: string;\n\n    /**\n     * Hide the prompt to display when the CLI is ready to accept input\n     */\n    hideUserName?: boolean;\n\n    /**\n     * Custom terminal options\n     */\n    terminalOptions?: ITerminalOptions & ITerminalInitOnlyOptions;\n};\n\n/**\n * Represents a package that can be installed\n */\nexport interface Package {\n    /**\n     * The name of the package\n     */\n    name: string;\n\n    /**\n     * The global name used to access the package\n     */\n    globalName?: string;\n\n    /**\n     * The version of the package\n     */\n    version: string;\n\n    /**\n     * The unpkg url to the package\n     */\n    url: string;\n}\n","import { ICliCommandAuthor } from '../interfaces';\n\nexport const DefaultLibraryAuthor: ICliCommandAuthor = {\n    name: 'Nicolae Lupei',\n    email: 'nicolae.lupei@qodalis.com',\n};\n\nexport const constants = {\n    DefaultLibraryAuthor,\n};\n","import { ICliCommandParameterDescriptor } from '../interfaces';\nimport { CliBackgroundColor, CliForegroundColor } from '../models';\n\nexport const getParameterValue = (\n    p: ICliCommandParameterDescriptor,\n    args: Record<string, any>,\n): any | undefined => {\n    return (\n        args[p.name] ??\n        (p.aliases?.find((alias) => args[alias]) &&\n            args[p.aliases!.find((alias) => args[alias])!])\n    );\n};\n\nexport const formatJson = (json: any): string => {\n    const identedJson = JSON.stringify(json, null, 2);\n\n    return colorizeJson(identedJson.split('\\n').join('\\r\\n'));\n};\n\nexport const colorizeJson = (jsonString: any): string => {\n    return jsonString\n        .replace(/\"([^\"]+)\":/g, '\\x1b[33m\"$1\":\\x1b[0m') // Keys (yellow)\n        .replace(/: \"([^\"]*)\"/g, ': \\x1b[32m\"$1\"\\x1b[0m') // Strings (green)\n        .replace(/: (\\d+)/g, ': \\x1b[34m$1\\x1b[0m') // Numbers (blue)\n        .replace(/: (true|false)/g, ': \\x1b[35m$1\\x1b[0m') // Booleans (magenta)\n        .replace(/: (null)/g, ': \\x1b[36m$1\\x1b[0m'); // Null (cyan)\n};\n\nexport const toQueryString = (params: Record<string, any>): string => {\n    const searchParams = new URLSearchParams();\n\n    for (const key in params) {\n        if (params.hasOwnProperty(key)) {\n            const value = params[key];\n            // Handle array and non-primitive values\n            if (Array.isArray(value)) {\n                value.forEach((v) => searchParams.append(key, v.toString()));\n            } else if (value !== null && value !== undefined) {\n                searchParams.append(key, value.toString());\n            }\n        }\n    }\n\n    return searchParams.toString();\n};\n\nexport const highlightTextWithBg = (\n    text: string,\n    pattern: RegExp,\n    bgColor: CliBackgroundColor = CliBackgroundColor.Yellow,\n): string => {\n    // Replace matches with background-colored text\n    return text.replace(\n        pattern,\n        (match) => `${bgColor}${match}${CliForegroundColor.Reset}`,\n    );\n};\n\nexport const getRightOfWord = (\n    command: string,\n    word: string,\n): string | undefined => {\n    // Find the position of the word in the command\n    const index = command.indexOf(word);\n\n    // If the word is found, extract the substring to the right\n    if (index !== -1) {\n        return command.slice(index + word.length).trim();\n    }\n\n    // If the word is not found, return null\n    return undefined;\n};\n\nexport const utils = {\n    getParameterValue,\n    formatJson,\n    colorizeJson,\n    toQueryString,\n    highlightTextWithBg,\n    getRightOfWord,\n};\n","import { constants } from '../constants';\nimport { ICliUmdModule } from '../interfaces';\nimport { utils } from '../utils';\n\nexport type CoreModuleProps = {\n    onUmdModuleBoot: ((module: ICliUmdModule) => Promise<void>)[];\n    bootUmdModule: (module: ICliUmdModule) => Promise<void>;\n    Injectable: () => {};\n};\n\nexport const initializeBrowserEnvironment = ({\n    handlers,\n}: {\n    handlers: ((module: ICliUmdModule) => Promise<void>)[];\n}): void => {\n    (window as any).core = {\n        onUmdModuleBoot: handlers || [],\n        bootUmdModule: async (module: ICliUmdModule) => {\n            handlers.forEach(async (handler) => await handler(module));\n        },\n        Injectable: () => ({}),\n        ...constants,\n        ...utils,\n    };\n};\n\nexport const bootUmdModule = async (module: ICliUmdModule): Promise<void> => {\n    if (typeof window !== 'undefined') {\n        (window as any)[module.name] = module;\n\n        await (window as any).core.bootUmdModule(module);\n    } else {\n        console.log('window is undefined');\n    }\n};\n","/*\n * Public API Surface of core\n */\n\nexport * from './lib/models';\n\nexport * from './lib/interfaces';\n\nexport * from './lib/modules';\n\nexport * from './lib/utils';\n\nexport * from './lib/constants';\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n"],"names":[],"mappings":"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"}

package/lib/constants/index.d.ts

@@ -0,0 +1,5 @@
+import { ICliCommandAuthor } from '../interfaces';
+export declare const DefaultLibraryAuthor: ICliCommandAuthor;
+export declare const constants: {
+    DefaultLibraryAuthor: ICliCommandAuthor;
+};

package/lib/interfaces/index.d.ts

@@ -1,6 +1,6 @@
 import { Terminal } from '@xterm/xterm';
 import { Observable, Subject } from 'rxjs';
-import { CliBackgroundColor, CliForegroundColor, CliOptions, CliProcessCommand, ICliUser, ICliUserSession } from '../models';
+import { CliBackgroundColor, CliForegroundColor, CliOptions, CliProcessCommand, ICliUser, ICliUserSession, Package } from '../models';
 export interface ICliCommandAuthor {
     /**
      * The name of the author
@@ -266,6 +266,11 @@ export interface ICliCommandExecutorService {
      * @param chainCommands
      */
     findProcessor(mainCommand: string, chainCommands: string[]): ICliCommandProcessor | undefined;
+    /**
+     * Register a processor
+     * @param processor
+     */
+    registerProcessor(processor: ICliCommandProcessor): void;
 }
 /**
  * Represents the context in which a command is executed
@@ -383,3 +388,20 @@ export interface ICliPingServerService {
      */
     ping(): Promise<void>;
 }
+/**
+ * Represents a module for the CLI
+ */
+export interface ICliUmdModule {
+    /**
+     * The name of the module
+     */
+    name: string;
+    /**
+     * The processors for the module
+     */
+    processors: ICliCommandProcessor[];
+    /**
+     * The dependencies for the module
+     */
+    dependencies?: Package[];
+}

package/lib/models/index.d.ts

@@ -83,3 +83,24 @@ export type CliOptions = {
      */
     terminalOptions?: ITerminalOptions & ITerminalInitOnlyOptions;
 };
+/**
+ * Represents a package that can be installed
+ */
+export interface Package {
+    /**
+     * The name of the package
+     */
+    name: string;
+    /**
+     * The global name used to access the package
+     */
+    globalName?: string;
+    /**
+     * The version of the package
+     */
+    version: string;
+    /**
+     * The unpkg url to the package
+     */
+    url: string;
+}

package/lib/modules/index.d.ts

@@ -0,0 +1,10 @@
+import { ICliUmdModule } from '../interfaces';
+export type CoreModuleProps = {
+    onUmdModuleBoot: ((module: ICliUmdModule) => Promise<void>)[];
+    bootUmdModule: (module: ICliUmdModule) => Promise<void>;
+    Injectable: () => {};
+};
+export declare const initializeBrowserEnvironment: ({ handlers, }: {
+    handlers: ((module: ICliUmdModule) => Promise<void>)[];
+}) => void;
+export declare const bootUmdModule: (module: ICliUmdModule) => Promise<void>;

package/lib/utils/index.d.ts

@@ -0,0 +1,16 @@
+import { ICliCommandParameterDescriptor } from '../interfaces';
+import { CliBackgroundColor } from '../models';
+export declare const getParameterValue: (p: ICliCommandParameterDescriptor, args: Record<string, any>) => any | undefined;
+export declare const formatJson: (json: any) => string;
+export declare const colorizeJson: (jsonString: any) => string;
+export declare const toQueryString: (params: Record<string, any>) => string;
+export declare const highlightTextWithBg: (text: string, pattern: RegExp, bgColor?: CliBackgroundColor) => string;
+export declare const getRightOfWord: (command: string, word: string) => string | undefined;
+export declare const utils: {
+    getParameterValue: (p: ICliCommandParameterDescriptor, args: Record<string, any>) => any | undefined;
+    formatJson: (json: any) => string;
+    colorizeJson: (jsonString: any) => string;
+    toQueryString: (params: Record<string, any>) => string;
+    highlightTextWithBg: (text: string, pattern: RegExp, bgColor?: CliBackgroundColor) => string;
+    getRightOfWord: (command: string, word: string) => string | undefined;
+};

package/package.json

@@ -1,6 +1,20 @@
 {
   "name": "@qodalis/cli-core",
-  "version": "0.0.1",
+  "version": "0.0.3",
+  "description": "An Angular CLI extension for generating and validating GUIDs.",
+  "author": "Nicolae Lupei, Qodalis Solutions",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/qodalis-solutions/qodalis-angular-cli"
+  },
+  "homepage": "https://qodalis.com",
+  "keywords": [
+    "angular",
+    "cli",
+    "qodalis",
+    "terminal"
+  ],
   "peerDependencies": {
     "@angular/common": "^16.2.0",
     "@angular/core": "^16.2.0"

package/public-api.d.ts

@@ -1,2 +1,5 @@
 export * from './lib/models';
 export * from './lib/interfaces';
+export * from './lib/modules';
+export * from './lib/utils';
+export * from './lib/constants';