@wfp/icons-core
Version:
Themes for un core
260 lines (249 loc) • 9.57 kB
JavaScript
;
Object.defineProperty(exports, '__esModule', { value: true });
var path$1 = require('path');
var fs$1 = require('fs');
var read = require('fs-readdir-recursive');
var del = require('del');
var core = require('@svgr/core');
var changeCase = require('change-case');
var svgo = require('svgo');
function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
var path__default = /*#__PURE__*/_interopDefaultLegacy(path$1);
var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs$1);
var read__default = /*#__PURE__*/_interopDefaultLegacy(read);
var del__default = /*#__PURE__*/_interopDefaultLegacy(del);
const { babel } = require('@rollup/plugin-babel');
const commonjs = require('@rollup/plugin-commonjs');
const { nodeResolve } = require('@rollup/plugin-node-resolve');
const { pascalCase } = require('change-case');
const fs = require('fs-extra');
const path = require('path');
const { rollup } = require('rollup');
async function bundle(entrypoint, options = { name: 'Icon', globals: undefined }) {
console.log('bundle rollup', entrypoint);
const customGlobals = options.globals ? formatGlobals(options.globals) : {};
options.globals ? formatGlobals(options.globals) : {};
const { name } = options;
const packageFolder = await findPackageFolder(entrypoint);
const outputFolders = [
{
format: 'esm',
directory: path.join(packageFolder, 'es'),
},
{
format: 'cjs',
directory: path.join(packageFolder, 'lib'),
},
{
format: 'umd',
directory: path.join(packageFolder, 'umd'),
},
];
await Promise.all(outputFolders.map(({ directory }) => fs.remove(directory)));
const jsEntryPoints = outputFolders.map(({ directory, format }) => ({
file: path.join(directory, 'index.js'),
format,
}));
const packageJsonPath = path.join(packageFolder, 'package.json');
const packageJson = await fs.readJson(packageJsonPath);
const { dependencies = {}, peerDependencies = {} } = packageJson;
const externalModules = [
...Object.keys(dependencies),
...Object.keys(peerDependencies),
'react/jsx-runtime',
'react/jsx-dev-runtime',
];
// Ensure 'react' and 'react-dom' are in uniqueExternalModules if they are peers
if (peerDependencies.react)
externalModules.push('react');
if (peerDependencies['react-dom'])
externalModules.push('react-dom');
const uniqueExternalModules = [...new Set(externalModules)];
const bundle = await rollup({
input: entrypoint,
external: uniqueExternalModules,
plugins: [
babel({
exclude: 'node_modules/**',
babelrc: false,
presets: [
[
'@babel/preset-env',
{
modules: false,
targets: {
browsers: ['last 1 version', 'ie >= 11', 'Firefox ESR'],
},
},
],
[
'@babel/preset-react',
{
runtime: 'automatic',
},
],
],
babelHelpers: 'bundled',
}),
nodeResolve(),
commonjs({
include: [/node_modules/],
extensions: ['.js', '.jsx'],
}),
],
});
await Promise.all(jsEntryPoints.map(({ format, file }) => {
const outputOptions = {
format,
file,
exports: 'auto',
name: 'not used',
globals: undefined,
};
if (format === 'umd') {
outputOptions.name = name;
outputOptions.globals = {
...formatDependenciesIntoGlobals(dependencies),
...formatDependenciesIntoGlobals(peerDependencies),
...customGlobals,
};
}
return bundle.write(outputOptions);
}));
}
function formatGlobals(string) {
const mappings = string.split(',').map((mapping) => {
return mapping.split('=');
});
return mappings.reduce((acc, [pkg, global]) => ({
...acc,
[pkg]: global,
}), {});
}
function formatDependenciesIntoGlobals(dependencies) {
return Object.keys(dependencies).reduce((acc, key) => {
const parts = key.split('/').map((identifier, i) => {
if (i === 0) {
return identifier.replace(/@/, '');
}
return identifier;
});
return {
...acc,
[key]: pascalCase(parts.join(' ')),
};
}, {});
}
async function findPackageFolder(entrypoint) {
let packageFolder = entrypoint;
while (packageFolder !== '/' && path.dirname(packageFolder) !== '/') {
packageFolder = path.dirname(packageFolder);
const packageJsonPath = path.join(packageFolder, 'package.json');
if (await fs.pathExists(packageJsonPath)) {
break;
}
}
return packageFolder;
}
const fsPromises = fs__default["default"].promises;
async function convertFolder(srcFolder, distFolder, convertFile, config) {
del__default["default"].sync([distFolder]);
fs__default["default"].mkdirSync(distFolder, { recursive: true });
var files = read__default["default"](srcFolder);
files = files.filter((file) => path__default["default"].extname(file) === '.svg');
await Promise.all(files.map(async (file) => {
return convertFile(path__default["default"].join(srcFolder, file), path__default["default"].join(distFolder, `${path__default["default"].parse(file).name}`), config);
}));
read__default["default"](distFolder).map((filePath) => {
console.log(filePath);
});
function defaultIndexTemplate(filePaths) {
const exportEntries = filePaths.map((filePath) => {
const basename = path__default["default"].basename(filePath, path__default["default"].extname(filePath));
//console.log(filePath);
/^\d/.test(basename) ? `Svg${basename}` : basename;
if (basename !== 'index')
return `export { default as ${basename} } from './${basename}';`;
});
return exportEntries.join('\n');
}
const distIndex = path__default["default"].join(distFolder, '/index.js');
async function writeIndex(distIndex) {
try {
return fsPromises.writeFile(distIndex, defaultIndexTemplate(read__default["default"](distFolder)));
}
catch (err) {
console.error('Error occured while reading directory!', err);
}
}
await writeIndex(distIndex);
// console.log(`Generated index: ${distIndex}`);
bundle(distIndex);
}
function svgConfig() {
return {
plugins: ['@svgr/plugin-svgo', '@svgr/plugin-jsx', '@svgr/plugin-prettier'],
replaceAttrValues: {
'#000000': 'currentColor',
'#000': 'currentColor',
//'#CCC': 'currentColor',
//'url(#a)': 'undefined',
},
svgoConfig: {
plugins: [
{
name: 'preset-default',
params: {
overrides: {
// customize default plugin options
/*inlineStyles: {
onlyMatchedOnce: false,
},
removeDoctype: false,
convertColors: false,*/
removeUnknownsAndDefaults: false,
removeViewBox: false,
},
},
},
],
},
icon: true,
};
}
//const fsPromises = fsPromises;
async function jsx(fileName, distName, svgConfig$1 = svgConfig) {
const svgCode = fs$1.readFileSync(fileName, 'utf8');
const name = changeCase.pascalCase(path__default["default"].parse(fileName).name);
const jsCode = await core.transform(svgCode, svgConfig$1( /*defaultSvgConfig()*/), {
componentName: name,
});
if (!fs$1.existsSync(path__default["default"].dirname(distName))) {
// console.log('Create directory: ', path.dirname(distName));
fs$1.mkdirSync(path__default["default"].dirname(distName), { recursive: true });
}
const output = path__default["default"].join(path__default["default"].dirname(distName), name + '.js');
await fs$1.promises.writeFile(output, jsCode);
return output;
}
async function svgOptimized(fileName, distName) {
const svgCode = fs$1.readFileSync(fileName, 'utf8');
const result = svgo.optimize(svgCode, {
// all config fields are also available here
multipass: true,
});
const optimizedSvgString = result.data;
if (!fs$1.existsSync(path$1.dirname(distName))) {
fs$1.mkdirSync(path$1.dirname(distName), { recursive: true });
}
const output = distName + '.svg';
fs$1.writeFile(output, optimizedSvgString, function (err) {
if (err)
return console.log(err);
console.log(`${fileName} > ${output}`);
});
}
exports.convertFolder = convertFolder;
exports.jsx = jsx;
exports.svgOptimized = svgOptimized;
//# sourceMappingURL=bundle.js.map