juisy 2.0.0-beta.9 → 2.0.1

package/dist/cli/plugins/register-bump-version-command/cmds/index.d.ts

@@ -1,3 +1,15 @@
 import { Command } from '../../../Command';
-declare const _default: Command;
-export default _default;
+import { CLIEngine, CommandHandlerArgs } from '../../../types';
+export default class BumpVersionCommand extends Command {
+    command: string;
+    describe: string;
+    meta: {
+        private: boolean;
+    };
+    builder(cli: CLIEngine): CLIEngine;
+    handler(argv: CommandHandlerArgs<{
+        preid: string;
+        file: string;
+        indent: number;
+    }>): Promise<void>;
+}

package/dist/cli/plugins/register-lint-commands/augment.d.ts

@@ -1,5 +1,6 @@
 import { default as ESLint } from 'eslint';
 import { default as LintStaged } from 'lint-staged';
+import { UserConfig as CommitLintConfig } from '@commitlint/types';
 import { SettingsLintMarkdown } from './types';
 declare module '../../types' {
     interface GlobalSettings {
@@ -14,10 +15,8 @@ declare module '../../types' {
             default?: UserProvidedConfigSetting<ESLint.Linter.LegacyConfig | ESLint.Linter.Config | ESLint.Linter.Config[]>;
             /**
              * Configuration for commitlint
-             * See also: https://github.com/conventional-changelog/commitlint
-             * Default: `{ extends: [ '@commitlint/config-conventional' ] }`
              */
-            commit?: UserProvidedConfigSetting<{}>;
+            commit?: UserProvidedConfigSetting<CommitLintConfig>;
             /**
              * Configuration for markdownlint (markdownlint-cli2)
              */

package/dist/cli/plugins/register-lint-commands/settings.d.ts

@@ -5,7 +5,7 @@ import { SettingsLintMarkdown } from './types';
  */
 export default function resolveSettings(settings?: Required<GlobalSettings>['lint']): {
     default?: import('../..').UserProvidedConfigSetting<import("eslint").Linter.LegacyConfig | import("eslint").Linter.Config | import("eslint").Linter.Config[]>;
-    commit?: import('../..').UserProvidedConfigSetting<{}>;
+    commit?: import('../..').UserProvidedConfigSetting<import('@commitlint/types').UserConfig>;
     markdown?: SettingsLintMarkdown;
     staged?: import('../..').UserProvidedConfigSetting<import('lint-staged').Config>;
 };

package/dist/cli/plugins/register-release-command/augment.d.ts

@@ -1,9 +1,9 @@
-import { default as ReleaseIt } from 'release-it';
+import { Config as ReleaseItConfig } from 'release-it';
 declare module '../../types' {
     interface GlobalSettings {
         /**
          * Release configuration
          */
-        release?: UserProvidedConfigSetting<ReleaseIt.Config>;
+        release?: UserProvidedConfigSetting<ReleaseItConfig>;
     }
 }

package/dist/cli/types.d.ts

@@ -1,4 +1,4 @@
-import { Argv, CommandModule as YargsCommandModule, MiddlewareFunction } from 'yargs';
+import { Argv, ArgumentsCamelCase, CommandModule as YargsCommandModule, MiddlewareFunction } from 'yargs';
 import { Command } from './Command';
 /**
  * An object whose all properties have the same type.
@@ -110,11 +110,15 @@ export interface CommandObject {
     /** string used as the description for the command in help text, use `false` for a hidden command */
     describe: YargsCommandModule['describe'];
     /** a function which will be passed the parsed argv. */
-    handler: CommandHandler;
+    handler: YargsCommandModule['handler'];
     /** object declaring the options the command accepts, or a function accepting and returning a yargs instance */
     builder: (cli: CLIEngine) => CLIEngine | PromiseLike<CLIEngine>;
     middlewares?: MiddlewareFunction[];
 }
+/**
+ * @group Types
+ */
+export type CommandHandlerArgs<T = {}> = ArgumentsCamelCase<T>;
 /**
  * @group Types
  */

package/dist/cli/utils.d.ts

@@ -1,4 +1,4 @@
-import { CommandObject, CLIEngine, CommandHandler } from './types';
+import { CommandObject, CLIEngine } from './types';
 /**
  * @ignore
  * @param target - The target builder
@@ -8,12 +8,3 @@ import { CommandObject, CLIEngine, CommandHandler } from './types';
  * that will be called before target. Target can be undefined
  */
 export declare function wrapCommandBuilder(target: CommandObject['builder'], builder: (cli: CLIEngine) => CLIEngine): (cli: CLIEngine) => CLIEngine | PromiseLike<CLIEngine>;
-/**
- * @ignore
- * @param target - The target handler
- * @param handler - The wrap
- * @description
- * Wrap command handler (target) with handler passed as second parameter
- * that will be called before target. Target can be undefined
- */
-export declare function wrapCommandhandler(target: CommandHandler, handler: CommandHandler): CommandHandler;

package/dist/eject.d.ts

@@ -7,6 +7,7 @@ export type EjectOptions = {
     targetDir?: string;
     logLevel?: LogLevelDesc;
     ignoreFiles?: string[];
+    templateData?: Record<string, any> | ((identifier: string) => Record<string, any> | Promise<Record<string, any>>);
     processor?: (content: string, identifier: string) => string | Promise<string>;
     onError?: (identifier: string, fromPath: string, toPath: string, err: Error) => void | Promise<void>;
     onSuccess?: (identifier: string, fromPath: string, toPath: string) => void | Promise<void>;
@@ -17,6 +18,7 @@ export type EjectOptions = {
  * @param options - The options object
  * @param options.force - If true, the target files will be overwritten
  * @param options.targetDir - The target directory absolute path
+ * @param options.templateData - The template data object
  * @param options.processor - The template file content processor function.
  * Takes content as unique argument and must return string or a Promise that resolves a string
  * @param options.onError - The callback if an error occurs

package/dist/index.js

@@ -1,5 +1,5 @@
 /*!
- * juisy v2.0.0-beta.9
+ * juisy v2.0.1
  * Copyright © 2022-Present Hervé Perchec
  */
 
@@ -123,6 +123,7 @@ async function isFile(filePath) {
 async function ejectFile(from, to, identifier = null, options) {
   identifier = identifier || path.basename(from);
   const force = options?.force || false;
+  const templateData = options?.templateData;
   const processor = options?.processor || (async (str, _identifier) => str);
   const onError = options?.onError || (async (_identifier, fromPath, toPath, err) => {
     throw err;
@@ -134,7 +135,7 @@ async function ejectFile(from, to, identifier = null, options) {
     const write = await fs.exists(to) ? force : true;
     if (write) {
       const template = await fs.readFile(from, { encoding: "utf8" });
-      const content = await templater.render(template);
+      const content = await templater.render(template, typeof templateData === "function" ? await templateData(identifier) : templateData);
       const processedContent = await processor(content, identifier);
       await fs.ensureFile(to);
       await fs.writeFile(to, processedContent);
@@ -160,6 +161,8 @@ async function eject(templateDir, identifier, options) {
       if (await isFile(fullPath)) {
         if (!ignoreFiles.includes(identifier)) {
           await ejectFile(fullPath, path.resolve(targetDir, identifier), identifier, {
+            force: options?.force,
+            templateData: options?.templateData,
             processor: options?.processor,
             onSuccess: options?.onSuccess,
             onError: options?.onError
@@ -171,6 +174,8 @@ async function eject(templateDir, identifier, options) {
           const fullTemplateFilePath = path.resolve(templateDir, fileRelativePath);
           if (!ignoreFiles.includes(fileRelativePath)) {
             await ejectFile(fullTemplateFilePath, path.resolve(targetDir, fileRelativePath), fileRelativePath, {
+              force: options?.force,
+              templateData: options?.templateData,
               processor: options?.processor,
               onSuccess: options?.onSuccess,
               onError: options?.onError
@@ -241,7 +246,7 @@ function defineGlobals(config, builder) {
   };
   return deepmerge(GLOBALS, JSON.parse(JSON.stringify(builder(ctx))));
 }
-async function getProjectGlobals(filePath = "./globals.config.js") {
+async function getProjectGlobals(filePath = "./project.globals.js") {
   return (await import(pathToFileURL(path.resolve(filePath)))).default;
 }
 

package/dist/project-globals.d.ts

@@ -3,7 +3,7 @@ import { IPackageJson as PackageJson, IAuthor as PackageJsonAuthor, IRepository
 /**
  * @group Types
  */
-export type ProjectGlobals = Record<string, string | Record<string, unknown> | undefined> & {
+export type DefaultProjectGlobals = {
     ENV: NodeJS.ProcessEnv;
     PACKAGE: {
         NAME: PackageJson['name'];
@@ -29,44 +29,25 @@ export type DotenvOptions = Omit<DotenvConfigOptions, 'processEnv'>;
 /**
  * @group Types
  */
-export type DefineGlobalsBuilder = (ctx: {
+export type DefineGlobalsBuilder<T extends Record<string, any>> = (ctx: {
     env: NodeJS.ProcessEnv;
     pkg: PackageJson;
-}) => ProjectGlobals;
+}) => T;
 /**
  * Define project globals
  * @param config - The config object
  * @param builder - The builder function
  * @returns The computed globals object
  */
-export declare function defineGlobals(config: {
+export declare function defineGlobals<CustomGlobals extends Record<string, any>>(config: {
     env?: {
         map?: string[];
         dotenvOptions?: DotenvOptions;
     };
-}, builder: DefineGlobalsBuilder): {
-    [x: string]: /*elided*/ any;
-    ENV: NodeJS.ProcessEnv;
-    PACKAGE: {
-        NAME: PackageJson["name"];
-        URL: PackageJson["url"];
-    };
-    VERSION: string;
-    AUTHOR: {
-        EMAIL: PackageJsonAuthor["email"];
-        NAME: PackageJsonAuthor["name"];
-        URL: PackageJsonAuthor["url"];
-    };
-    REPOSITORY: {
-        TYPE: PackageJsonRepository["type"];
-        URL: PackageJsonRepository["url"];
-    };
-    ISSUES_URL: string;
-    HOMEPAGE: string;
-};
+}, builder: DefineGlobalsBuilder<CustomGlobals>): DefaultProjectGlobals & CustomGlobals;
 /**
  * Get project globals
- * @param filePath - The filePath. Default is `'./globals.config.js'`
+ * @param filePath - The filePath. Default is `'./project.globals.js'`
  * @returns The resolved project globals object
  */
-export declare function getProjectGlobals(filePath?: string): Promise<ProjectGlobals>;
+export declare function getProjectGlobals(filePath?: string): Promise<DefaultProjectGlobals & Record<string, string | Record<string, unknown> | undefined>>;

package/dist/templater/index.js

@@ -1,5 +1,5 @@
 /*!
- * juisy v2.0.0-beta.9
+ * juisy v2.0.1
  * Copyright © 2022-Present Hervé Perchec
  */
 
@@ -184,7 +184,7 @@ class ReadmeTemplater {
     }, data), options.data);
     let template = await fs.readFile(processedConfig.templatePath, { encoding: "utf8" });
     if (processedConfig.appendAutoGenMessage) {
-      template += "\n----\n\n*<%= $config.fileName %> - this file was auto generated with [juisy](https://www.npmjs.com/package/juisy) README templater. Don't edit it.*\n";
+      template += "\n----\n<!-- markdownlint-disable-next-line line-length -->\n*<%= $config.fileName %> - this file was auto generated with [juisy](https://www.npmjs.com/package/juisy) README templater. Don't edit it.*\n";
     }
     return await this.templater.render(template, ejsData, processedConfig.ejsOptions);
   }

package/dist/vite/plugins/inject-css-variables/index.d.ts

@@ -0,0 +1,23 @@
+import { Plugin } from 'vite';
+export type Options = {
+    /**
+     * The virtual module ID
+     */
+    moduleId: string;
+    /**
+     * The CSS selector.
+     * @default ':root'
+     */
+    selector?: string;
+    /**
+     * The CSS variables object
+     */
+    variables: Record<string, string>;
+};
+/**
+ * Inject CSS variables via a virtual module
+ * @param opts - The plugin options or an array of options
+ * @returns {Plugin} The vite plugin function
+ */
+export declare function injectCssVariables(optsArg?: Options | Array<Options>): Plugin;
+export default injectCssVariables;

package/dist/vite/plugins/inject-css-variables/index.js

@@ -0,0 +1,60 @@
+/*!
+ * juisy v2.0.1
+ * Copyright © 2022-Present Hervé Perchec
+ */
+
+function injectCssVariables(optsArg = []) {
+  const optionsArray = optsArg instanceof Array ? optsArg : [optsArg];
+  const virtualModules = /* @__PURE__ */ new Map();
+  for (let i = 0; i < optionsArray.length; i++) {
+    const options = optionsArray[i];
+    if (!options.moduleId || options.moduleId.trim().length === 0) {
+      throw new Error(`Please provide a non-empty module ID in plugin options at index ${i}`);
+    }
+    if (virtualModules.has(options.moduleId)) {
+      throw new Error(`The module ID "${options.moduleId}" is already used. Please provide another ID`);
+    }
+    virtualModules.set(options.moduleId, options);
+  }
+  return {
+    name: "vite-plugin-inject-css-variables",
+    enforce: "pre",
+    resolveId(id) {
+      const options = virtualModules.get(id);
+      if (!options) {
+        return;
+      } else {
+        return "\0" + options.moduleId;
+      }
+    },
+    async load(id) {
+      const options = virtualModules.get(id.slice(1));
+      if (!id.startsWith("\0") || !options) {
+        return;
+      }
+      const { selector = ":root", variables } = options;
+      try {
+        if (Object.keys(variables).length === 0) {
+          return "";
+        }
+        for (const key in variables) {
+          if (typeof variables[key] === "string") {
+            continue;
+          }
+        }
+      } catch (e) {
+        this.error(`The variables object for module "${options.moduleId}" is malformed`);
+      }
+      let css = `${selector} {
+`;
+      for (const key in variables) {
+        css += `  --${key}: ${variables[key]};
+`;
+      }
+      css += "}\n";
+      return css;
+    }
+  };
+}
+
+export { injectCssVariables as default, injectCssVariables };

package/dist/vite/plugins/inject-project-globals/index.d.ts

@@ -0,0 +1,19 @@
+import { Plugin } from 'vite';
+export type Options = {
+    /**
+     * The virtual module ID
+     * @default 'virtual:project.globals.js'
+     */
+    moduleId?: string;
+    /**
+     * The project globals path (relative from root folder)
+     */
+    filePath?: string;
+};
+/**
+ * Inject project globals via a virtual module
+ * @param opts - The plugin options or an array of options
+ * @returns {Plugin} The vite plugin function
+ */
+export declare function injectProjectGlobals(options?: Options): Plugin;
+export default injectProjectGlobals;

package/dist/vite/plugins/inject-project-globals/index.js

@@ -0,0 +1,58 @@
+/*!
+ * juisy v2.0.1
+ * Copyright © 2022-Present Hervé Perchec
+ */
+
+import { getProjectGlobals } from 'juisy';
+import { OutputUtils } from 'juisy/cli';
+
+function injectProjectGlobals(options = {}) {
+  const { $style } = OutputUtils;
+  let config;
+  let moduleId = "virtual:project.globals.js";
+  if (options.moduleId) {
+    if (options.moduleId.trim().length === 0) {
+      throw new Error("Please provide a non-empty module ID for juisy/vite-plugin-inject-project-globals");
+    }
+    moduleId = options.moduleId;
+  }
+  return {
+    name: "vite-plugin-inject-project-globals",
+    enforce: "pre",
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+    },
+    resolveId(id) {
+      if (id !== moduleId) {
+        return;
+      } else {
+        return "\0" + moduleId;
+      }
+    },
+    /**
+     * Vite plugin `load` hook
+     * @param id - The requested module ID
+     * @returns The module content as a string
+     * @description
+     * Load the virtual module and return its content.
+     * If the module ID is not the one defined by the plugin, simply return null.
+     * Otherwise, call `getProjectGlobals` and build a js string.
+     */
+    async load(id) {
+      if (!id.startsWith("\0") || id.slice(1) !== moduleId) {
+        return;
+      }
+      const PROJECT_GLOBALS = {
+        ...await getProjectGlobals(options.filePath)
+      };
+      if (PROJECT_GLOBALS.ENV) {
+        config.logger.warn("\n[vite-plugin-inject-project-globals] " + $style.yellow("The following ENV variables are exposed:"));
+        config.logger.warn(JSON.stringify(PROJECT_GLOBALS.ENV));
+        config.logger.warn("\n");
+      }
+      return "const PROJECT_GLOBALS = " + JSON.stringify(PROJECT_GLOBALS) + "\nconst isBrowser = import.meta.env.SSR === false\nif (isBrowser) {\n  if (PROJECT_GLOBALS.ENV) {\n    console.warn('[vite-plugin-inject-project-globals] WARNING: some ENV variables are exposed! Be careful, do not expose sensitive data!')\n  }\n}\nexport default PROJECT_GLOBALS\n";
+    }
+  };
+}
+
+export { injectProjectGlobals as default, injectProjectGlobals };