juisy 2.0.0-beta.0

package/dist/eject.d.ts

@@ -0,0 +1,22 @@
+import { LogLevelDesc } from 'loglevel';
+type EjectOptions = {
+    force?: boolean;
+    targetDir?: string;
+    logLevel?: LogLevelDesc;
+    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>;
+};
+/**
+ * Eject from file from template to user project
+ * @param identifier - The identifier of the file to eject (relative to juisy/template folder). Can be a glob pattern (ex: `bin\/**\/*`).
+ * @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.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
+ * @param options.onSuccess - The callback in of success
+ */
+export default function eject(identifier: string, options?: EjectOptions): Promise<void>;
+export {};

package/dist/get-package-info.d.ts

@@ -0,0 +1,6 @@
+import { IPackageJson as PackageJson } from 'package-json-type';
+/**
+ * Get package.json content
+ * @returns The package.json content as object
+ */
+export default function getPackageInfo(): PackageJson;

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Public API of juisy library
+ * @module juisy
+ * @author Hervé Perchec
+ */
+import * as utils from './utils/misc';
+export { default as eject } from './eject';
+export * from './DataExporter';
+export { default as getPackageInfo } from './get-package-info';
+export * from './project-globals';
+export { utils };

package/dist/index.js

@@ -0,0 +1,244 @@
+/*!
+ * juisy v1.4.0
+ * Copyright © 2022-Present Hervé Perchec
+ */
+
+import path, { dirname } from 'node:path';
+import { readdir, readFileSync } from 'node:fs';
+import { glob } from 'glob';
+import fs from 'fs-extra';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { packageDirectorySync } from 'pkg-dir';
+import log from 'loglevel';
+import { Templater } from 'juisy/templater';
+import yaml from 'yaml';
+import { json2csv } from 'json-2-csv';
+import jstoxml from 'jstoxml';
+import dotenv from '@dotenvx/dotenvx';
+import deepmerge from 'deepmerge';
+
+function getFileUrls(pattern, options) {
+  const files = glob.sync(pattern, options || {});
+  return files;
+}
+async function* getFiles(dir) {
+  const dirents = await readdir(dir, { withFileTypes: true });
+  for (const dirent of dirents) {
+    const res = path.resolve(dir, dirent.name);
+    if (dirent.isDirectory()) {
+      yield* getFiles(res);
+    } else {
+      yield res;
+    }
+  }
+}
+
+const misc = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+    __proto__: null,
+    getFileUrls,
+    getFiles
+}, Symbol.toStringTag, { value: 'Module' }));
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const templater = new Templater("ejs", {
+  engineOptions: {
+    // ...
+  }
+});
+async function isDirectory(filePath) {
+  try {
+    const stats = await fs.stat(filePath);
+    return stats.isDirectory();
+  } catch (err) {
+    return false;
+  }
+}
+async function isFile(filePath) {
+  try {
+    const stats = await fs.stat(filePath);
+    return stats.isFile();
+  } catch (err) {
+    return false;
+  }
+}
+async function ejectFile(from, to, identifier = null, options) {
+  identifier = identifier || path.basename(from);
+  const force = options?.force || false;
+  const processor = options?.processor || (async (str, _identifier) => str);
+  const onError = options?.onError || (async (_identifier, fromPath, toPath, err) => {
+    throw err;
+  });
+  const onSuccess = options?.onSuccess || (async (_identifier, fromPath, toPath) => {
+    log.info(`File ${_identifier} successfuly ejected!`);
+  });
+  try {
+    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 processedContent = await processor(content, identifier);
+      await fs.ensureFile(to);
+      await fs.writeFile(to, processedContent);
+      await onSuccess(identifier, from, to);
+    } else {
+      log.warn(`Target "${to}" already exists. Skipped... Use "force" option to overwrite`);
+    }
+  } catch (err) {
+    await onError(identifier, from, to, err);
+  }
+}
+async function eject(identifier, options) {
+  const targetDir = options?.targetDir || packageDirectorySync() || process.cwd();
+  const logLevel = options?.logLevel || "trace";
+  const originalLogLevel = log.getLevel();
+  log.setLevel(logLevel);
+  if (!identifier) {
+    throw new Error("eject: identifier is required");
+  } else {
+    try {
+      const localTemplatePath = path.resolve(__dirname, "../template");
+      const fullPath = path.resolve(localTemplatePath, identifier);
+      if (await isFile(fullPath)) {
+        await ejectFile(fullPath, path.resolve(targetDir, identifier), identifier, {
+          processor: options?.processor,
+          onSuccess: options?.onSuccess,
+          onError: options?.onError
+        });
+      } else {
+        const globPattern = await isDirectory(fullPath) ? identifier + "/**/*" : identifier;
+        for (const fileRelativePath of getFileUrls(globPattern, { cwd: localTemplatePath, nodir: true, posix: true })) {
+          const fullTemplateFilePath = path.resolve(localTemplatePath, fileRelativePath);
+          await ejectFile(fullTemplateFilePath, path.resolve(targetDir, fileRelativePath), fileRelativePath, {
+            processor: options?.processor,
+            onSuccess: options?.onSuccess,
+            onError: options?.onError
+          });
+        }
+      }
+      log.info(`Successfully ejected "${identifier}"`);
+    } finally {
+      log.setLevel(originalLogLevel);
+    }
+  }
+}
+
+const xml = jstoxml.toXML;
+const SUPPORTED_FORMATS = [
+  "json",
+  "yaml",
+  "csv",
+  "xml"
+  // 'bson',
+  // 'msgpack',
+  // 'protobuf',
+  // 'avro'
+];
+const jsonExporter = function(data, options = {}) {
+  return JSON.stringify(data, options.replacer, options.space);
+};
+const yamlExporter = function(data, options = {}) {
+  return yaml.stringify(data, options.replacer, options.exporter);
+};
+const csvExporter = function(data, options) {
+  return json2csv(data, options);
+};
+const xmlExporter = function(data, options) {
+  return xml(data, options);
+};
+class DataExporter {
+  /**
+   * The target format
+   */
+  format;
+  /**
+   * Creates new instance of Costume
+   * @param options - Costume options
+   */
+  constructor(format) {
+    if (SUPPORTED_FORMATS.includes(format)) {
+      this.format = format;
+    } else {
+      throw new Error(`DataConverter: Unsupported "${format}" format`);
+    }
+  }
+  exportSync(data, options) {
+    switch (this.format) {
+      case "json":
+        return jsonExporter(data, options);
+      case "yaml":
+        return yamlExporter(data, options);
+      case "csv":
+        return csvExporter(data, options);
+      case "xml":
+        return xmlExporter(data, options);
+    }
+  }
+  export(...args) {
+    return new Promise((resolve, reject) => {
+      resolve(this.exportSync(...args));
+    });
+  }
+}
+
+function getPackageInfo() {
+  const pkgPath = path.resolve(packageDirectorySync(), "./package.json");
+  return JSON.parse(readFileSync(pkgPath, "utf8"));
+}
+
+function defineGlobals(config, builder) {
+  const env = {
+    ...process.env
+  };
+  let pkg = {};
+  try {
+    pkg = getPackageInfo();
+  } catch (error) {
+    console.warn("Unable to find or parse package.json:", error.message);
+  }
+  const GLOBALS = {
+    ENV: {},
+    PACKAGE: {
+      NAME: pkg.name,
+      URL: `https://www.npmjs.com/package/${pkg.name}`
+    },
+    VERSION: pkg.version,
+    AUTHOR: {
+      EMAIL: pkg.author?.email,
+      NAME: pkg.author?.name,
+      URL: pkg.author?.url
+    },
+    REPOSITORY: {
+      TYPE: pkg.repository?.type,
+      URL: pkg.repository?.url
+    },
+    ISSUES_URL: pkg.bugs?.url,
+    HOMEPAGE: pkg.homepage
+  };
+  if (config.env?.map?.length) {
+    dotenv.config({
+      // Default to not verbose, can be overridden
+      debug: false,
+      verbose: false,
+      quiet: true,
+      // Spread user options
+      ...config.env.dotenvOptions || {},
+      // DON'T write to process.env.
+      // We pass custom local temporary object
+      processEnv: env
+    });
+    for (const envVar of config.env.map) {
+      GLOBALS.ENV[envVar] = env[envVar];
+    }
+  }
+  const ctx = {
+    env,
+    pkg
+  };
+  return deepmerge(GLOBALS, JSON.parse(JSON.stringify(builder(ctx))));
+}
+async function getProjectGlobals(filePath = "./globals.config.js") {
+  return (await import(pathToFileURL(path.resolve(filePath)))).default;
+}
+
+export { DataExporter, defineGlobals, eject, getPackageInfo, getProjectGlobals, misc as utils };

package/dist/project-globals.d.ts

@@ -0,0 +1,63 @@
+import { DotenvConfigOptions } from '@dotenvx/dotenvx';
+import { IPackageJson as PackageJson, IAuthor as PackageJsonAuthor, IRepository as PackageJsonRepository, IBugs as PackageJsonBugs } from 'package-json-type';
+export type ProjectGlobals = Record<string, string | Record<string, unknown> | undefined> & {
+    ENV: NodeJS.ProcessEnv;
+    PACKAGE: {
+        NAME: PackageJson['name'];
+        URL: PackageJson['url'];
+    };
+    VERSION: PackageJson['version'];
+    AUTHOR: {
+        EMAIL: PackageJsonAuthor['email'];
+        NAME: PackageJsonAuthor['name'];
+        URL: PackageJsonAuthor['url'];
+    };
+    REPOSITORY: {
+        TYPE: PackageJsonRepository['type'];
+        URL: PackageJsonRepository['url'];
+    };
+    ISSUES_URL: PackageJsonBugs['url'];
+    HOMEPAGE: PackageJson['homepage'];
+};
+export type DotenvOptions = Omit<DotenvConfigOptions, 'processEnv'>;
+export type DefineGlobalsBuilder = (ctx: {
+    env: NodeJS.ProcessEnv;
+    pkg: PackageJson;
+}) => ProjectGlobals;
+/**
+ * Define project globals
+ * @param config - The config object
+ * @param builder - The builder function
+ * @returns The computed globals object
+ */
+export declare function defineGlobals(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;
+};
+/**
+ * Get project globals
+ * @param filePath - The filePath. Default is `'./globals.config.js'`
+ * @returns The resolved project globals object
+ */
+export declare function getProjectGlobals(filePath?: string): Promise<ProjectGlobals>;

package/dist/templater/Templater.d.ts

@@ -0,0 +1,23 @@
+import { SupportedEngines, TemplaterOptions } from './types';
+export declare class Templater {
+    constructor(engine: 'handlebars', options?: TemplaterOptions<'handlebars'>);
+    constructor(engine: 'ejs', options?: TemplaterOptions<'ejs'>);
+    constructor(engine: 'pug', options?: TemplaterOptions<'pug'>);
+    constructor(engine: SupportedEngines[number], options?: TemplaterOptions<SupportedEngines[number]>);
+    private engine;
+    private defaultData;
+    private methodsMap;
+    /**
+     * @returns Get the engine
+     */
+    getEngine(): unknown;
+    /**
+     * Renders a template with the given context.
+     */
+    render(template: string, data?: undefined, options?: any): Promise<string>;
+    /**
+     * Renders a template file with the given context.
+     * @todo not yet implemented
+     */
+    renderFile(filePath: string, context?: Record<string, any>): string;
+}

package/dist/templater/index.d.ts

@@ -0,0 +1,6 @@
+export { Templater } from './Templater';
+export { MarkdownTemplater } from './markdown-templater';
+export { ReadmeTemplater } from './markdown-templater/ReadmeTemplater';
+export type * from './types';
+export type { MarkdownTemplaterOptions } from './markdown-templater';
+export type { UserConfiguration as ReadmeTemplaterUserConfiguration } from './markdown-templater/ReadmeTemplater';