balm-core 5.2.0 → 6.0.0-alpha.1

package/lib/utilities/public-url.js

@@ -1,37 +0,0 @@
-import { URL } from 'node:url';
-import { DOMAIN } from '../config/constants.js';
-
-/**
- * Returns a URL or a path with slash at the end
- * In production can be URL, absolute path, relative path
- * In development always will be an absolute path
- * In development can use `path` module functions for operations
- */
-function getPublicUrlOrPath(homepage, envPublicUrl) {
-  const stubDomain = DOMAIN;
-  if (envPublicUrl) {
-    // ensure last slash exists
-    envPublicUrl = envPublicUrl.endsWith('/') ? envPublicUrl : envPublicUrl + '/';
-
-    // validate if `envPublicUrl` is a URL or path like
-    // `stubDomain` is ignored if `envPublicUrl` contains a domain
-    const validPublicUrl = new URL(envPublicUrl, stubDomain);
-    return BalmJS.config.env.isDev ? envPublicUrl.startsWith('.') ? '/' : validPublicUrl.pathname :
-    // Some apps do not use client-side routing with pushState.
-    // For these, "homepage" can be set to "." to enable relative asset paths.
-    envPublicUrl;
-  }
-  if (homepage) {
-    // strip last slash if exists
-    homepage = homepage.endsWith('/') ? homepage : homepage + '/';
-
-    // validate if `homepage` is a URL or path like and use just pathname
-    const validHomepagePathname = new URL(homepage, stubDomain).pathname;
-    return BalmJS.config.env.isDev ? homepage.startsWith('.') ? '/' : validHomepagePathname :
-    // Some apps do not use client-side routing with pushState.
-    // For these, "homepage" can be set to "." to enable relative asset paths.
-    homepage.startsWith('.') ? homepage : validHomepagePathname;
-  }
-  return '/';
-}
-export default getPublicUrlOrPath;

package/lib/utilities/replacestream.js

@@ -1,106 +0,0 @@
-import { Transform } from 'readable-stream';
-import escapeRegExp from './escape-string-regexp.js';
-function createReplaceFn(replace, isRegEx) {
-  function regexReplaceFunction(...args) {
-    let newReplace = replace;
-
-    // ability to us $1 with captures
-    // Start at 1 and end at length - 2 to avoid the match parameter and offset
-    // And string parameters
-    const paramLength = [...args].length - 2;
-    for (let i = 1; i < paramLength; i++) {
-      newReplace = newReplace.replace(new RegExp(`\\$${i}`, 'g'), [...args][i] || '');
-    }
-    return newReplace;
-  }
-  if (!(replace instanceof Function)) {
-    return isRegEx ? regexReplaceFunction : () => {
-      return replace;
-    };
-  }
-  return replace;
-}
-function matchFromRegex(regex, options) {
-  if (options.regExpFlags) {
-    regex = new RegExp(regex.source, options.regExpFlags);
-  }
-
-  // If there is no global flag then there can only be one match
-  if (!regex.global) {
-    options.limit = 1;
-  }
-  return regex;
-}
-function matchFromString(str, options) {
-  if (options.regExpFlags) {
-    return new RegExp(escapeRegExp(str), options.regExpFlags);
-  }
-  return new RegExp(escapeRegExp(str), options.ignoreCase ? 'gmi' : 'gm');
-}
-function replaceStream(search, replace, opts) {
-  const options = Object.assign({
-    limit: Infinity,
-    encoding: 'utf8',
-    maxMatchLen: 100
-  }, opts);
-  let tail = '';
-  let totalMatches = 0;
-  const isRegex = search instanceof RegExp;
-  const replaceFn = createReplaceFn(replace, isRegex);
-  let match;
-  if (isRegex) {
-    match = matchFromRegex(search, options);
-  } else {
-    match = matchFromString(search, options);
-    options.maxMatchLen = search.length;
-  }
-  function getDataToAppend(before, match) {
-    let dataToAppend = before;
-    totalMatches++;
-    dataToAppend += isRegex ? replaceFn.apply(this, match.concat([match.index.toString(), match.input])) : replaceFn(match[0]);
-    return dataToAppend;
-  }
-  function getDataToQueue(matchCount, haystack, rewritten, lastPos) {
-    if (matchCount > 0) {
-      if (haystack.length > tail.length) {
-        return rewritten + haystack.slice(lastPos, haystack.length - tail.length);
-      }
-      return rewritten;
-    }
-    return haystack.slice(0, haystack.length - tail.length);
-  }
-  function transform(chunk, encoding, callback) {
-    let matches;
-    let lastPos = 0;
-    let matchCount = 0;
-    let rewritten = '';
-    const haystack = `${tail}${chunk.toString(options.encoding)}`;
-    tail = '';
-    while (totalMatches < options.limit && (matches = match.exec(haystack)) !== null) {
-      matchCount++;
-      const before = haystack.slice(lastPos, matches.index);
-      const regexMatch = matches;
-      lastPos = matches.index + regexMatch[0].length;
-      if (lastPos > haystack.length && regexMatch[0].length < options.maxMatchLen) {
-        tail = regexMatch[0];
-      } else {
-        const dataToAppend = getDataToAppend(before, regexMatch);
-        rewritten += dataToAppend;
-      }
-    }
-    if (tail.length < 1) tail = haystack.slice(lastPos).length > options.maxMatchLen ? haystack.slice(lastPos).slice(0 - options.maxMatchLen) : haystack.slice(lastPos);
-    const dataToQueue = getDataToQueue(matchCount, haystack, rewritten, lastPos);
-    callback(null, dataToQueue);
-  }
-  function flush(callback) {
-    if (tail) {
-      this.push(tail);
-    }
-    callback();
-  }
-  return new Transform({
-    transform,
-    flush
-  });
-}
-export default replaceStream;

package/lib/utilities/typeof.js

@@ -1,5 +0,0 @@
-const reTypeOf = /(?:^\[object\s(.*?)\]$)/;
-function getType(obj) {
-  return Object.prototype.toString.call(obj).replace(reTypeOf, '$1').toLowerCase();
-}
-export default getType;

package/lib/utilities/utils.js

@@ -1,43 +0,0 @@
-import getType from './typeof.js';
-function isString(str) {
-  return getType(str) === 'string';
-}
-function isObject(obj) {
-  return getType(obj) === 'object';
-}
-function isArray(arr) {
-  return Array.isArray(arr);
-}
-function isFunction(fn) {
-  const type = getType(fn);
-  return type === 'function' || type === 'generatorfunction';
-}
-
-// Deep merge two objects
-function deepMerge(target, source) {
-  if (isObject(target) && isObject(source)) {
-    Object.keys(source).forEach(key => {
-      if (isObject(source[key])) {
-        if (!target[key]) {
-          Object.assign(target, {
-            [key]: {}
-          });
-        }
-        deepMerge(target[key], source[key]);
-      } else {
-        Object.assign(target, {
-          [key]: source[key]
-        });
-      }
-    });
-  }
-  return target;
-}
-export default {
-  getType,
-  isString,
-  isObject,
-  isArray,
-  isFunction,
-  deepMerge
-};

package/tslib/balm.js

@@ -1,44 +0,0 @@
-import './config/index.js';
-import './utilities/index.js';
-import './plugins/index.js';
-import registerTasks from './tasks/index.js';
-import { setConfig, setTask } from './bootstrap/index.js';
-import loading from './utilities/loading.js';
-class Balm {
-    #config;
-    constructor() {
-        BalmJS.loading = false;
-        loading.succeed();
-        this.#config = setConfig({});
-    }
-    get config() {
-        return this.#config;
-    }
-    set config(value) {
-        this.#config = setConfig(value);
-        BalmJS.config = this.#config;
-    }
-    set beforeTask(name) {
-        BalmJS.beforeTask = setTask(name);
-    }
-    set afterTask(name) {
-        BalmJS.afterTask = setTask(name);
-    }
-    go(recipe = NOOP) {
-        if (BalmJS.utils.isFunction(recipe)) {
-            registerTasks(recipe);
-        }
-        else {
-            BalmJS.logger.error('initialization', 'BalmJS API: `balm.go(mix => {});`');
-        }
-    }
-    reset() {
-        BalmJS.tasks = new Map();
-        BalmJS.recipes = [];
-        BalmJS.recipeIndex = 0;
-        BalmJS.beforeTask = undefined;
-        BalmJS.afterTask = undefined;
-        BalmJS.config.useDefaults = true;
-    }
-}
-export default Balm;

package/tslib/bootstrap/check_config.js

@@ -1,36 +0,0 @@
-import { DOMAIN } from '../config/constants.js';
-const docsBaseURL = `${DOMAIN}/docs/config`;
-function upgradeGuide(key, value, message) {
-    const page = key === 'scripts' ? 'scripts-webpack' : key.toLowerCase();
-    return `${message} See ${docsBaseURL}/${page}.html#${key}-${value.toLowerCase()}`;
-}
-function upgradeRenamed(version, configCategory, from, to) {
-    if (BalmJS.config[configCategory][from]) {
-        BalmJS.logger.warn(`balm@${version}+ config`, upgradeGuide(configCategory, to, `'${configCategory}.${from}' was renamed to '${configCategory}.${to}'.`));
-    }
-}
-function upgradeMigrated(version, configName, from, to) {
-    if (BalmJS.config[from][configName]) {
-        BalmJS.logger.warn(`balm@${version}+ config`, upgradeGuide(to, configName, `'${from}.${configName}' was migrated to '${to}.${configName}'.`));
-    }
-}
-function upgradeDeprecated(version, configCategory, configName) {
-    if (BalmJS.config[configCategory][configName]) {
-        BalmJS.logger.warn(`balm@${version}+ config`, `'${configCategory}.${configName}' was deprecated.`);
-    }
-}
-function checkConfig() {
-    upgradeRenamed('2.5.0', 'scripts', 'disableDefaultLoaders', 'defaultLoaders');
-    upgradeMigrated('2.11.0', 'postcssLoaderOptions', 'styles', 'scripts');
-    upgradeRenamed('2.22.0', 'images', 'defaultPlugins', 'plugins');
-    upgradeRenamed('3.0.0', 'styles', 'minified', 'minify');
-    upgradeRenamed('3.9.0', 'scripts', 'options', 'minifyOptions');
-    upgradeRenamed('3.16.0', 'scripts', 'inject', 'useCache');
-    upgradeDeprecated('3.17.0', 'styles', 'darkSass');
-    upgradeDeprecated('3.19.0', 'scripts', 'useCache');
-    upgradeDeprecated('4.0.0', 'scripts', 'libraryTarget');
-    upgradeDeprecated('4.5.0', 'scripts', 'excludeUrlResource');
-    upgradeDeprecated('4.5.0', 'scripts', 'urlLoaderOptions');
-    upgradeRenamed('4.29.0', 'server', 'proxyConfig', 'proxyOptions');
-}
-export default checkConfig;

package/tslib/bootstrap/index.js

@@ -1,82 +0,0 @@
-import checkConfig from './check_config.js';
-import { ASSETS_TYPES } from '../config/constants.js';
-function createQuickPath(config, rootKey) {
-    const result = {};
-    const rootValue = config.roots[rootKey];
-    for (const pathKey of Object.keys(config.paths[rootKey])) {
-        const pathValue = config.paths[rootKey][pathKey];
-        result[pathKey] =
-            rootKey === 'target' && ASSETS_TYPES.includes(pathKey)
-                ? node.path.join(rootValue, BalmJS.config.assets.virtualDir, BalmJS.file.assetsSuffixPath, pathValue)
-                : node.path.join(rootValue, pathValue);
-    }
-    return rootKey === 'source'
-        ? result
-        : result;
-}
-function ready(config) {
-    config.src = createQuickPath(config, 'source');
-    config.dest = createQuickPath(config, config.env.isProd || !config.inFrontend ? 'target' : 'tmp');
-    config.dest.static = node.path.join(config.dest.base, BalmJS.config.assets.virtualDir, BalmJS.file.assetsSuffixPath);
-    config.assets.static = node.path.join(config.assets.root, config.assets.mainDir, BalmJS.file.assetsSuffixPath);
-    for (const assetType of ASSETS_TYPES) {
-        config.assets[assetType] = node.path.join(config.assets.static, config.paths.target[assetType]);
-    }
-    const HMR_ENV = config.useDefaults &&
-        config.env.isDev &&
-        !config.env.inSSR &&
-        !config.env.isMP;
-    const HMR_Enabling = config.scripts.bundler === BalmJS.Bundler.webpack && !config.scripts.ie8;
-    config.server.useHMR = HMR_ENV && HMR_Enabling;
-    if (/^electron-.*/.test(config.scripts.target)) {
-        config.env.inDesktopApp = true;
-    }
-    config.scripts.useCache =
-        config.env.isProd && config.assets.cache && config.scripts.injectHtml;
-    return config;
-}
-function resetConfig() {
-    BalmJS.config.roots.target = 'dist';
-    BalmJS.config.roots.tmp = '.tmp';
-    return BalmJS.config;
-}
-function setConfig(customConfig) {
-    const defaultConfig = resetConfig();
-    const newConfig = BalmJS.utils.deepMerge(defaultConfig, customConfig);
-    checkConfig();
-    let config = BalmJS.utils.deepMerge(newConfig, {
-        paths: {
-            tmp: newConfig.paths.target
-        }
-    });
-    if (!config.inFrontend) {
-        if (config.roots.target === 'dist') {
-            config.roots.target = config.assets.mainDir;
-        }
-        config.roots.tmp = config.roots.target;
-    }
-    config = ready(config);
-    BalmJS.logger.success('balm configuration', config, {
-        pre: true
-    });
-    return config;
-}
-function setTask(name) {
-    let result = undefined;
-    if (BalmJS.utils.isFunction(name)) {
-        result = name;
-    }
-    else if (BalmJS.utils.isString(name)) {
-        if (gulp.tree().nodes.includes(name)) {
-            result = name;
-        }
-        else {
-            BalmJS.logger.error('before/end task', 'Invalid gulp task name');
-        }
-    }
-    else {
-        BalmJS.logger.error('before/end task', 'Task must be a string (gulp task name) or function');
-    }
-    return result;
-}
-export { setConfig, setTask };

package/tslib/bundler/esbuild/build.js

@@ -1,30 +0,0 @@
-import { build } from 'esbuild';
-import { minifyOptions } from './options.js';
-const esBuild = (entryPoints, output, customBuildOptions, callback) => {
-    const defaultBuildOptions = {
-        entryPoints: BalmJS.file.absPaths(entryPoints),
-        outdir: BalmJS.file.absPath(output),
-        bundle: BalmJS.config.env.isProd
-    };
-    const buildOptions = BalmJS.config.env.isProd
-        ? Object.assign(defaultBuildOptions, minifyOptions)
-        : defaultBuildOptions;
-    const options = Object.assign(buildOptions, BalmJS.config.scripts.buildOptions, customBuildOptions);
-    BalmJS.logger.debug('esbuild bundler - build', {
-        input: options.entryPoints,
-        output: options.outdir
-    }, {
-        pre: true
-    });
-    BalmJS.logger.success('esbuild options', options, {
-        pre: true
-    });
-    build(options)
-        .catch((error) => {
-        BalmJS.logger.error('esbuild', error.message);
-    })
-        .finally(() => {
-        callback();
-    });
-};
-export default esBuild;

package/tslib/bundler/esbuild/index.js

@@ -1,11 +0,0 @@
-import build from './build.js';
-import transform from './transform.js';
-const esbuild = (input, output, customOptions, callback) => {
-    const entryPoints = BalmJS.utils.isString(input)
-        ? [input]
-        : input;
-    BalmJS.config.scripts.useTransform
-        ? transform(entryPoints, output, customOptions, callback)
-        : build(entryPoints, output, customOptions, callback);
-};
-export default esbuild;

package/tslib/bundler/esbuild/options.js

@@ -1,7 +0,0 @@
-const minifyOptions = {
-    minify: true,
-    minifyWhitespace: true,
-    minifyIdentifiers: true,
-    minifySyntax: true
-};
-export { minifyOptions };

package/tslib/bundler/esbuild/transform.js

@@ -1,38 +0,0 @@
-import { transform } from 'esbuild';
-import { minifyOptions } from './options.js';
-const esTransform = (entryPoints, output, customTransformOptions, callback) => {
-    const build = {
-        output: BalmJS.file.absPath(output)
-    };
-    const transformOptions = BalmJS.config.env.isProd
-        ? Object.assign({}, minifyOptions)
-        : {};
-    const options = Object.assign(transformOptions, BalmJS.config.scripts.transformOptions, customTransformOptions);
-    (async () => {
-        try {
-            for await (const entryPoint of entryPoints) {
-                build.input = BalmJS.file.absPath(entryPoint);
-                BalmJS.logger.debug('esbuild bundler - transform', {
-                    input: build.input,
-                    output: build.output
-                }, {
-                    pre: true
-                });
-                const filename = entryPoint.split('/').pop();
-                if (filename && node.fs.existsSync(build.input)) {
-                    const inputCode = node.fs.readFileSync(build.input, 'utf8');
-                    const result = await transform(inputCode, options);
-                    node.fs.mkdirSync(build.output, { recursive: true });
-                    node.fs.writeFileSync(node.path.join(build.output, filename), result.code);
-                }
-                else {
-                    BalmJS.logger.warn('esbuild', `Invalid entry point: ${entryPoint}`);
-                }
-            }
-        }
-        finally {
-            callback();
-        }
-    })();
-};
-export default esTransform;

package/tslib/bundler/rollup/build.js

@@ -1,17 +0,0 @@
-const build = async (bundle, outputOptions) => {
-    const { output } = await bundle.generate(outputOptions);
-    for (const chunkOrAsset of output) {
-        if (chunkOrAsset.type === 'asset') {
-            BalmJS.logger.debug('rollup bundler - Asset', chunkOrAsset, {
-                pre: true
-            });
-        }
-        else {
-            BalmJS.logger.debug('rollup bundler - Chunk', chunkOrAsset.modules, {
-                pre: true
-            });
-        }
-    }
-    return await bundle.write(outputOptions);
-};
-export default build;

package/tslib/bundler/rollup/entry.js

@@ -1,24 +0,0 @@
-import { getInputPlugins } from './plugins.js';
-function getEntry(inputOptions) {
-    const inputPlugins = getInputPlugins(inputOptions);
-    const options = Object.assign({}, BalmJS.config.scripts.inputOptions, inputOptions);
-    options.plugins = inputPlugins;
-    const { input } = options;
-    let rollupEntries = input;
-    if (BalmJS.utils.isObject(input)) {
-        const entries = input;
-        Object.keys(entries).forEach((entryAlias) => {
-            entries[entryAlias] = BalmJS.file.absPath(entries[entryAlias]);
-        });
-        rollupEntries = entries;
-    }
-    else {
-        rollupEntries = BalmJS.file.absPaths(input);
-    }
-    options.input = rollupEntries;
-    BalmJS.logger.debug('rollup input options', options, {
-        pre: true
-    });
-    return options;
-}
-export default getEntry;

package/tslib/bundler/rollup/index.js

@@ -1,21 +0,0 @@
-import { rollup } from 'rollup';
-import getEntry from './entry.js';
-import getOutput from './output.js';
-import build from './build.js';
-const buildLibrary = async (inputOptions, outputOptions) => {
-    inputOptions = getEntry(inputOptions);
-    outputOptions = getOutput(outputOptions);
-    const rollupOptions = Object.assign({}, inputOptions, {
-        output: outputOptions
-    });
-    const bundle = await rollup(rollupOptions);
-    if (Array.isArray(outputOptions)) {
-        for await (const outputOption of outputOptions) {
-            await build(bundle, outputOption);
-        }
-    }
-    else {
-        await build(bundle, outputOptions);
-    }
-};
-export default buildLibrary;

package/tslib/bundler/rollup/output.js

@@ -1,23 +0,0 @@
-import { getOutputPlugins } from './plugins.js';
-function setOutput(outputOptions) {
-    const outputPlugins = getOutputPlugins(outputOptions);
-    outputOptions = Object.assign({}, BalmJS.config.scripts.outputOptions, outputOptions);
-    outputOptions.plugins = outputPlugins;
-    if (outputOptions.dir) {
-        outputOptions.dir = BalmJS.file.absPath(outputOptions.dir);
-    }
-    else {
-        outputOptions.file = BalmJS.file.absPath(outputOptions.file);
-    }
-    return outputOptions;
-}
-function getOutput(outputOptions) {
-    const options = Array.isArray(outputOptions)
-        ? outputOptions.map((outputOption) => setOutput(outputOption))
-        : setOutput(outputOptions);
-    BalmJS.logger.debug('rollup output options', options, {
-        pre: true
-    });
-    return options;
-}
-export default getOutput;

package/tslib/bundler/rollup/plugins.js

@@ -1,27 +0,0 @@
-import terser from '@rollup/plugin-terser';
-function getInputPlugins(customInputOptions) {
-    const { inputOptions } = BalmJS.config.scripts;
-    const inputPlugins = [];
-    if (inputOptions.plugins) {
-        inputPlugins.push(...inputOptions.plugins);
-    }
-    if (customInputOptions.plugins) {
-        inputPlugins.push(...customInputOptions.plugins);
-    }
-    return inputPlugins;
-}
-function getOutputPlugins(customOutputOptions) {
-    const { outputOptions } = BalmJS.config.scripts;
-    const outputPlugins = [];
-    if (outputOptions.plugins) {
-        outputPlugins.push(...outputOptions.plugins);
-    }
-    if (BalmJS.config.env.isProd) {
-        outputPlugins.push(terser(BalmJS.config.scripts.minifyOptions));
-    }
-    if (customOutputOptions.plugins) {
-        outputPlugins.push(...customOutputOptions.plugins);
-    }
-    return outputPlugins;
-}
-export { getInputPlugins, getOutputPlugins };