juisy 2.0.0-beta.9 → 2.1.0

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,9 +1,9 @@
 /*!
- * juisy v2.0.0-beta.9
+ * juisy v2.1.0
  * Copyright © 2022-Present Hervé Perchec
  */
 
-import path, { dirname } from 'node:path';
+import path$1, { dirname } from 'node:path';
 import { readdir, readFileSync } from 'node:fs';
 import { glob } from 'glob';
 import yaml from 'yaml';
@@ -24,7 +24,7 @@ function getFileUrls(pattern, options) {
 async function* getFiles(dir) {
   const dirents = await readdir(dir, { withFileTypes: true });
   for (const dirent of dirents) {
-    const res = path.resolve(dir, dirent.name);
+    const res = path$1.resolve(dir, dirent.name);
     if (dirent.isDirectory()) {
       yield* getFiles(res);
     } else {
@@ -32,11 +32,61 @@ async function* getFiles(dir) {
     }
   }
 }
+const path = {
+  /**
+   * Convert a path to win32 format (with `\\` separator)
+   * @param val - The path to convert
+   * @example
+   * utils.path.toWin32('a/posix/path') // => 'a\posix\path'
+   * utils.path.toWin32('C:\\a\\win32\\absolute\\path') // => 'C:\a\win32\absolute\path'
+   * utils.path.toWin32('a/mixed\\path') // => 'a\mixed\path'
+   */
+  toWin32(val) {
+    return val.split(path$1.posix.sep).join(path$1.win32.sep);
+  },
+  /**
+   * Convert a path to posix format (with `/` separator)
+   * @param val - The path to convert
+   * @example
+   * utils.path.toPosix('a/posix/path') // => 'a/posix/path'
+   * utils.path.toPosix('C:\\a\\win32\\absolute\\path') // => 'C:/a/win32/absolute/path'
+   * utils.path.toPosix('a/mixed\\path') // => 'a/mixed/path'
+   */
+  toPosix(val) {
+    return val.split(path$1.win32.sep).join(path$1.posix.sep);
+  },
+  /**
+   * Automatically convert a path to OS specific format
+   * @param val - The path to convert
+   */
+  toOsFormat(val) {
+    const platform = process.platform;
+    return platform === "win32" ? path.toWin32(val) : path.toPosix(val);
+  },
+  /**
+   * Util to resolve relative file path to root directory
+   * @param from - The "from" absolute file path
+   * @param to - The "to" absolute file path
+   * @param separator - (Optional) The separator type: can be `"posix"` or `"win32"`
+   * @returns The resolved relative path to root directory
+   * @example
+   * const base = 'C:\\Users\\JohnDoe\\Documents\\Projects\\MyProject'
+   *
+   * utils.path.resolveRel(base, 'C:\\Users\\JohnDoe\\Documents\\Projects\\MyProject\\src\\index.ts') // 'src\\index.ts'
+   * utils.path.resolveRel('C:\\Users\\JohnDoe\\Documents\\Projects\\MyProject\\src\\index.ts', base) // '..\\..'
+   * utils.path.resolveRel(base, 'C:\\Users\\JohnDoe\\Documents\\Projects\\MyProject\\src\\index.ts', 'posix') // 'src/index.ts'
+   */
+  resolveRel(from, to, separator) {
+    const relativePath = path$1.relative(from, to);
+    return separator ? separator === "posix" ? path.toPosix(relativePath) : path.toWin32(relativePath) : path.toOsFormat(relativePath);
+  }
+};
 
 const misc = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
     __proto__: null,
     getFileUrls,
-    getFiles
+    getFiles,
+    path
 }, Symbol.toStringTag, { value: 'Module' }));
 
 const xml = jstoxml.toXML;
@@ -121,8 +171,9 @@ async function isFile(filePath) {
   }
 }
 async function ejectFile(from, to, identifier = null, options) {
-  identifier = identifier || path.basename(from);
+  identifier = identifier || path$1.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 +185,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);
@@ -156,10 +207,12 @@ async function eject(templateDir, identifier, options) {
     throw new Error("eject: identifier is required");
   } else {
     try {
-      const fullPath = path.resolve(templateDir, identifier);
+      const fullPath = path$1.resolve(templateDir, identifier);
       if (await isFile(fullPath)) {
         if (!ignoreFiles.includes(identifier)) {
-          await ejectFile(fullPath, path.resolve(targetDir, identifier), identifier, {
+          await ejectFile(fullPath, path$1.resolve(targetDir, identifier), identifier, {
+            force: options?.force,
+            templateData: options?.templateData,
             processor: options?.processor,
             onSuccess: options?.onSuccess,
             onError: options?.onError
@@ -168,9 +221,11 @@ async function eject(templateDir, identifier, options) {
       } else {
         const globPattern = await isDirectory(fullPath) ? identifier + "/**/*" : identifier;
         for (const fileRelativePath of getFileUrls(globPattern, { cwd: templateDir, nodir: true, posix: true, dot: true })) {
-          const fullTemplateFilePath = path.resolve(templateDir, fileRelativePath);
+          const fullTemplateFilePath = path$1.resolve(templateDir, fileRelativePath);
           if (!ignoreFiles.includes(fileRelativePath)) {
-            await ejectFile(fullTemplateFilePath, path.resolve(targetDir, fileRelativePath), fileRelativePath, {
+            await ejectFile(fullTemplateFilePath, path$1.resolve(targetDir, fileRelativePath), fileRelativePath, {
+              force: options?.force,
+              templateData: options?.templateData,
               processor: options?.processor,
               onSuccess: options?.onSuccess,
               onError: options?.onError
@@ -186,7 +241,7 @@ async function eject(templateDir, identifier, options) {
 }
 
 function getPackageInfo() {
-  const pkgPath = path.resolve(packageDirectorySync(), "./package.json");
+  const pkgPath = path$1.resolve(packageDirectorySync(), "./package.json");
   return JSON.parse(readFileSync(pkgPath, "utf8"));
 }
 
@@ -241,8 +296,8 @@ function defineGlobals(config, builder) {
   };
   return deepmerge(GLOBALS, JSON.parse(JSON.stringify(builder(ctx))));
 }
-async function getProjectGlobals(filePath = "./globals.config.js") {
-  return (await import(pathToFileURL(path.resolve(filePath)))).default;
+async function getProjectGlobals(filePath = "./project.globals.js") {
+  return (await import(pathToFileURL(path$1.resolve(filePath)))).default;
 }
 
 export { DataExporter, defineGlobals, eject, getPackageInfo, getProjectGlobals, misc as utils };

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.1.0
  * 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/utils/misc.d.ts

@@ -1,7 +1,7 @@
 import { GlobOptions } from 'glob';
 /**
  * @param pattern - Same as node-glob pattern argument
- * @param options - Same as gloab options argument
+ * @param options - Same as glob options argument
  * @returns {string[]} Returns an array of file path
  * @description
  * Get file urls that match glob (see: https://github.com/isaacs/node-glob)
@@ -19,3 +19,45 @@ export declare function getFileUrls(pattern: string, options?: GlobOptions): str
  * utils.getFiles(path) // => [ 'path/to/file1', 'path/to/file2', ... ]
  */
 export declare function getFiles(dir: string): AsyncGenerator<string[]>;
+/**
+ * Utils related to path
+ */
+export declare const path: {
+    /**
+     * Convert a path to win32 format (with `\\` separator)
+     * @param val - The path to convert
+     * @example
+     * utils.path.toWin32('a/posix/path') // => 'a\posix\path'
+     * utils.path.toWin32('C:\\a\\win32\\absolute\\path') // => 'C:\a\win32\absolute\path'
+     * utils.path.toWin32('a/mixed\\path') // => 'a\mixed\path'
+     */
+    toWin32(val: string): string;
+    /**
+     * Convert a path to posix format (with `/` separator)
+     * @param val - The path to convert
+     * @example
+     * utils.path.toPosix('a/posix/path') // => 'a/posix/path'
+     * utils.path.toPosix('C:\\a\\win32\\absolute\\path') // => 'C:/a/win32/absolute/path'
+     * utils.path.toPosix('a/mixed\\path') // => 'a/mixed/path'
+     */
+    toPosix(val: string): string;
+    /**
+     * Automatically convert a path to OS specific format
+     * @param val - The path to convert
+     */
+    toOsFormat(val: string): string;
+    /**
+     * Util to resolve relative file path to root directory
+     * @param from - The "from" absolute file path
+     * @param to - The "to" absolute file path
+     * @param separator - (Optional) The separator type: can be `"posix"` or `"win32"`
+     * @returns The resolved relative path to root directory
+     * @example
+     * const base = 'C:\\Users\\JohnDoe\\Documents\\Projects\\MyProject'
+     *
+     * utils.path.resolveRel(base, 'C:\\Users\\JohnDoe\\Documents\\Projects\\MyProject\\src\\index.ts') // 'src\\index.ts'
+     * utils.path.resolveRel('C:\\Users\\JohnDoe\\Documents\\Projects\\MyProject\\src\\index.ts', base) // '..\\..'
+     * utils.path.resolveRel(base, 'C:\\Users\\JohnDoe\\Documents\\Projects\\MyProject\\src\\index.ts', 'posix') // 'src/index.ts'
+     */
+    resolveRel(from: string, to: string, separator?: "posix" | "win32"): string;
+};

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.1.0
+ * 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.1.0
+ * 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 };