@shuvi/toolpack 0.0.1-pre.1

package/lib/webpack/config/base.js

@@ -0,0 +1,236 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const webpack_chain_1 = __importDefault(require("webpack-chain"));
+exports.WebpackChain = webpack_chain_1.default;
+const terser_webpack_plugin_1 = __importDefault(require("terser-webpack-plugin"));
+const webpack_1 = __importDefault(require("webpack"));
+const path_1 = __importDefault(require("path"));
+const constants_1 = require("@shuvi/shared/lib/constants");
+const detectTypescript_1 = require("@shuvi/utils/lib/detectTypescript");
+const escapeRegExp_1 = require("@shuvi/utils/lib/escapeRegExp");
+const build_manifest_plugin_1 = __importDefault(require("../plugins/build-manifest-plugin"));
+const module_replace_plugin_1 = __importDefault(require("../plugins/module-replace-plugin"));
+const chunk_names_plugin_1 = __importDefault(require("../plugins/chunk-names-plugin"));
+const fix_watching_plugin_1 = __importDefault(require("../plugins/fix-watching-plugin"));
+const require_cache_hot_reloader_plugin_1 = __importDefault(require("../plugins/require-cache-hot-reloader-plugin"));
+const constants_2 = require("../../constants");
+const crypto_1 = __importDefault(require("crypto"));
+const dumbRouteComponent = require.resolve('../../utils/emptyComponent');
+const resolveLocalLoader = (name) => path_1.default.join(__dirname, `../loaders/${name}`);
+const terserOptions = {
+    parse: {
+        ecma: 2017 // es8 === 2017
+    },
+    compress: {
+        ecma: 5,
+        // The following two options are known to break valid JavaScript code
+        comparisons: false,
+        inline: 2 // https://github.com/zeit/next.js/issues/7178#issuecomment-493048965
+    },
+    mangle: { safari10: true },
+    output: {
+        ecma: 5,
+        safari10: true,
+        comments: false,
+        // Fixes usage of Emoji and certain Regex
+        ascii_only: true
+    }
+};
+function baseWebpackChain({ dev, projectRoot, srcDirs, mediaFilename, name, buildManifestFilename, publicPath = '/', env = {} }) {
+    const { typeScriptPath, tsConfigPath, useTypeScript } = detectTypescript_1.getTypeScriptInfo(projectRoot);
+    const config = new webpack_chain_1.default();
+    config.mode(dev ? 'development' : 'production');
+    config.bail(!dev);
+    config.performance.hints(false);
+    config.context(projectRoot);
+    config.optimization.merge({
+        emitOnErrors: !dev,
+        checkWasmTypes: false,
+        nodeEnv: false,
+        splitChunks: false,
+        runtimeChunk: undefined,
+        minimize: !dev,
+        realContentHash: false
+    });
+    if (!dev) {
+        config.optimization.minimizer('terser').use(terser_webpack_plugin_1.default, [
+            {
+                extractComments: false,
+                parallel: true,
+                terserOptions
+            }
+        ]);
+    }
+    config.output.merge({
+        publicPath,
+        hotUpdateChunkFilename: 'static/webpack/[id].[fullhash].hot-update.js',
+        hotUpdateMainFilename: 'static/webpack/[fullhash].hot-update.json',
+        // This saves chunks with the name given via `import()`
+        chunkFilename: `static/chunks/${dev ? '[name]' : '[name].[contenthash:8]'}.js`,
+        strictModuleExceptionHandling: true,
+        // crossOriginLoading: crossOrigin,
+        webassemblyModuleFilename: 'static/wasm/[modulehash:8].wasm'
+    });
+    // Support for NODE_PATH
+    const nodePathList = (process.env.NODE_PATH || '')
+        .split(process.platform === 'win32' ? ';' : ':')
+        .filter(p => !!p);
+    config.resolve.merge({
+        modules: [
+            'node_modules',
+            ...nodePathList // Support for NODE_PATH environment variable
+        ],
+        alias: {}
+    });
+    config.resolveLoader.merge({
+        alias: ['shuvi-babel-loader', 'route-component-loader'].reduce((alias, loader) => {
+            alias[`@shuvi/${loader}`] = resolveLocalLoader(loader);
+            return alias;
+        }, {})
+    });
+    config.module.set('strictExportPresence', true);
+    const mainRule = config.module.rule('main');
+    // TODO: FIXME: await babel/babel-loader to update to fix this.
+    // x-ref: https://github.com/webpack/webpack/issues/11467
+    config.module
+        .rule('webpackPatch')
+        .test(/\.m?js/)
+        .resolve.set('fullySpecified', false);
+    mainRule
+        .oneOf('js')
+        .test(/\.(tsx|ts|js|mjs|jsx)$/)
+        .include.merge([...srcDirs, ...constants_2.AppSourceRegexs])
+        .end()
+        .exclude.add((path) => {
+        if (constants_2.AppSourceRegexs.some(r => r.test(path))) {
+            return false;
+        }
+        if (srcDirs.some(src => path.includes(src))) {
+            return false;
+        }
+        return /node_modules/.test(path);
+    })
+        .end()
+        .use('shuvi-babel-loader')
+        .loader('@shuvi/shuvi-babel-loader')
+        .options({
+        isNode: false,
+        // webpack 5 have in-built cache.
+        cacheDirectory: false
+    });
+    mainRule
+        .oneOf('media')
+        .exclude.merge([/\.(js|mjs|jsx|ts|tsx)$/, /\.html$/, /\.json$/])
+        .end()
+        .use('file-loader')
+        .loader(require.resolve('file-loader'))
+        .options({
+        name: mediaFilename
+    });
+    config.plugin('chunk-names').use(chunk_names_plugin_1.default);
+    config.plugin('private/ignore-plugin').use(webpack_1.default.IgnorePlugin, [
+        {
+            resourceRegExp: /^\.\/locale$/,
+            contextRegExp: /moment$/
+        }
+    ]);
+    const shuviPublicEnv = Object.keys(process.env).reduce((prev, key) => {
+        if (key.startsWith(constants_1.PUBLIC_ENV_PREFIX)) {
+            prev[`process.env.${key}`] = JSON.stringify(process.env[key]);
+        }
+        return prev;
+    }, {});
+    const shuviConfigEnv = Object.keys(env).reduce((acc, key) => {
+        if (/^(?:NODE_.+)|^(?:__.+)$/i.test(key)) {
+            throw new Error(`The key "${key}" under "env" is not allowed.`);
+        }
+        return Object.assign(Object.assign({}, acc), { [`process.env.${key}`]: JSON.stringify(env[key]) });
+    }, {});
+    config.plugin('define').use(webpack_1.default.DefinePlugin, [
+        Object.assign(Object.assign(Object.assign({}, shuviPublicEnv), shuviConfigEnv), { 'process.env.NODE_ENV': JSON.stringify(dev ? 'development' : 'production') })
+    ]);
+    config
+        .plugin('private/build-manifest')
+        .use(build_manifest_plugin_1.default, [
+        { filename: buildManifestFilename, chunkRequest: dev }
+    ]);
+    if (useTypeScript) {
+        config
+            .plugin('private/fork-ts-checker-webpack-plugin')
+            .use(require.resolve('fork-ts-checker-webpack-plugin'), [
+            {
+                typescript: {
+                    configFile: tsConfigPath,
+                    typeScriptPath,
+                    diagnosticOptions: {
+                        syntactic: true
+                    }
+                },
+                async: dev,
+                logger: {
+                    infrastructure: 'silent',
+                    issues: 'silent',
+                    devServer: false
+                },
+                formatter: 'codeframe'
+            }
+        ]);
+    }
+    const getCacheConfig = () => {
+        const projectHash = crypto_1.default
+            .createHash('md5')
+            .update(projectRoot)
+            .digest('hex');
+        const stringifiedEnvs = Object.entries(Object.assign(Object.assign({}, shuviConfigEnv), shuviPublicEnv)).reduce((prev, [key, value]) => {
+            return `${prev}|${key}=${value}`;
+        }, '');
+        const SHUVI_VERSION = require('shuvi/package.json').version;
+        return {
+            cacheDirectory: path_1.default.resolve(`node_modules/.cache/webpack/${projectHash}`),
+            type: 'filesystem',
+            name: `${name.replace(/\//, '-')}-${config.get('mode')}`,
+            version: `${SHUVI_VERSION}|${stringifiedEnvs}`
+        };
+    };
+    config.cache(typeof process.env.SHUVI_DEV_DISABLE_CACHE !== 'undefined'
+        ? false
+        : getCacheConfig());
+    if (dev) {
+        // For webpack-dev-middleware usage
+        config.watchOptions({
+            // timeout 300 will make hmr.test to failed, set to 350
+            aggregateTimeout: 350,
+            ignored: ['**/.git/**', '**/node_modules/**']
+        });
+        config.set('infrastructureLogging', {
+            level: 'none'
+        });
+        config.plugin('private/fix-watching-plugin').use(fix_watching_plugin_1.default);
+        config.plugin('private/module-replace-plugin').use(module_replace_plugin_1.default, [
+            {
+                modules: [
+                    {
+                        resourceQuery: RegExp(escapeRegExp_1.escapeRegExp(`?${constants_1.ROUTE_RESOURCE_QUERYSTRING}`)),
+                        module: dumbRouteComponent
+                    }
+                ]
+            }
+        ]);
+        // Even though require.cache is server only we have to clear assets from both compilations
+        // This is because the client compilation generates the build manifest that's used on the server side
+        config
+            .plugin('private/require-cache-hot-reloader')
+            .use(require_cache_hot_reloader_plugin_1.default);
+        config.optimization.usedExports(false);
+    }
+    else {
+        config
+            .plugin('private/hashed-moduleids-plugin')
+            .use(webpack_1.default.ids.HashedModuleIdsPlugin);
+    }
+    return config;
+}
+exports.baseWebpackChain = baseWebpackChain;

package/lib/webpack/config/browser.d.ts

@@ -0,0 +1,8 @@
+import WebpackChain from 'webpack-chain';
+import { BaseOptions } from './base';
+import { IWebpackHelpers } from '../types';
+export interface BrowserOptions extends BaseOptions {
+    webpackHelpers: IWebpackHelpers;
+    analyze?: boolean;
+}
+export declare function createBrowserWebpackChain({ webpackHelpers, ...baseOptions }: BrowserOptions): WebpackChain;

package/lib/webpack/config/browser.js

@@ -0,0 +1,147 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = __importDefault(require("crypto"));
+const webpack_1 = __importDefault(require("webpack"));
+const webpack_bundle_analyzer_1 = require("webpack-bundle-analyzer");
+const detectTypescript_1 = require("@shuvi/utils/lib/detectTypescript");
+// import PreferResolverPlugin from '../plugins/prefer-resolver-plugin';
+const base_1 = require("./base");
+const style_1 = require("./parts/style");
+const BIG_LIBRARY_THRESHOLD = 160000; // byte
+function createBrowserWebpackChain(_a) {
+    var { webpackHelpers } = _a, baseOptions = __rest(_a, ["webpackHelpers"]);
+    const { dev, publicPath, analyze } = baseOptions;
+    const chain = base_1.baseWebpackChain(baseOptions);
+    const { useTypeScript } = detectTypescript_1.getTypeScriptInfo(baseOptions.projectRoot);
+    chain.target('web');
+    chain.devtool(dev ? 'cheap-module-source-map' : false);
+    chain.resolve.extensions.merge([
+        ...(useTypeScript ? ['.tsx', '.ts'] : []),
+        '.mjs',
+        '.js',
+        '.jsx',
+        '.json',
+        '.wasm'
+    ]);
+    // if (baseOptions.target) {
+    //   chain.resolve
+    //     .plugin('private/prefer-resolver-plugin')
+    //     .use(PreferResolverPlugin, [{ suffix: baseOptions.target }]);
+    // }
+    if (dev) {
+        chain.plugin('private/hmr-plugin').use(webpack_1.default.HotModuleReplacementPlugin);
+    }
+    else {
+        chain.optimization.splitChunks({
+            chunks: 'all',
+            cacheGroups: {
+                default: false,
+                defaultVendors: false,
+                framework: {
+                    chunks: 'all',
+                    name: 'framework',
+                    // This regex ignores nested copies of framework libraries so they're
+                    // bundled with their issuer.
+                    // https://github.com/zeit/next.js/pull/9012
+                    test: /(?<!node_modules.*)[\\/]node_modules[\\/](react|react-dom|@shuvi\/router|@shuvi\/router-react|scheduler|prop-types|use-subscription|history)[\\/]/,
+                    priority: 40,
+                    // Don't let webpack eliminate this chunk (prevents this chunk from
+                    // becoming a part of the commons chunk)
+                    enforce: true
+                },
+                lib: {
+                    test(module) {
+                        return (module.size() > BIG_LIBRARY_THRESHOLD &&
+                            /node_modules[/\\]/.test(module.identifier()));
+                    },
+                    name(module) {
+                        const hash = crypto_1.default.createHash('sha1');
+                        if (module.type === `css/mini-extract`) {
+                            module.updateHash(hash);
+                        }
+                        else {
+                            if (!module.libIdent) {
+                                throw new Error(`Encountered unknown module type: ${module.type}. Please open an issue.`);
+                            }
+                            hash.update(module.libIdent({ context: baseOptions.projectRoot }));
+                        }
+                        return hash.digest('hex').substring(0, 8);
+                    },
+                    priority: 30,
+                    minChunks: 1,
+                    reuseExistingChunk: true
+                },
+                commons: {
+                    name: 'commons',
+                    minChunks: 2,
+                    priority: 20
+                },
+                shared: {
+                    name(module, chunks) {
+                        return crypto_1.default
+                            .createHash('sha1')
+                            .update(chunks.reduce((acc, chunk) => {
+                            return acc + chunk.name;
+                        }, ''))
+                            .digest('hex');
+                    },
+                    priority: 10,
+                    minChunks: 2,
+                    reuseExistingChunk: true
+                }
+            },
+            maxInitialRequests: 25,
+            minSize: 20000
+        });
+        if (analyze) {
+            chain.plugin('private/bundle-analyzer-plugin').use(webpack_bundle_analyzer_1.BundleAnalyzerPlugin, [
+                {
+                    logLevel: 'warn',
+                    openAnalyzer: false,
+                    analyzerMode: 'static',
+                    reportFilename: '../analyze/client.html'
+                }
+            ]);
+        }
+    }
+    chain.resolve.alias
+        .set('stream', require.resolve('stream-browserify'))
+        .set('path', require.resolve('path-browserify'))
+        .set('crypto', require.resolve('crypto-browserify'))
+        .set('buffer', require.resolve('buffer'))
+        .set('vm', require.resolve('vm-browserify'));
+    chain.plugin('node-buffer-polyfill').use(webpack_1.default.ProvidePlugin, [
+        {
+            Buffer: ['buffer', 'Buffer']
+        }
+    ]);
+    chain.plugin('node-process-polyfill').use(webpack_1.default.ProvidePlugin, [
+        {
+            process: ['process']
+        }
+    ]);
+    chain.plugin('define').tap(([options]) => [
+        Object.assign(Object.assign({}, options), { __BROWSER__: true, 
+            // prevent errof of destructing process.env
+            'process.env': JSON.stringify('{}') })
+    ]);
+    chain.plugin('private/build-manifest').tap(([options]) => [
+        Object.assign(Object.assign({}, options), { modules: true })
+    ]);
+    return style_1.withStyle(chain, { extractCss: !dev, publicPath });
+}
+exports.createBrowserWebpackChain = createBrowserWebpackChain;

package/lib/webpack/config/index.d.ts

@@ -0,0 +1,4 @@
+export * from './base';
+export * from './browser';
+export * from './node';
+export * from './parts/helpers';

package/lib/webpack/config/index.js

@@ -0,0 +1,9 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(require("./base"));
+__export(require("./browser"));
+__export(require("./node"));
+__export(require("./parts/helpers"));

package/lib/webpack/config/node.d.ts

@@ -0,0 +1,7 @@
+import WebpackChain from 'webpack-chain';
+import { BaseOptions } from './base';
+import { IWebpackHelpers } from '../types';
+export interface NodeOptions extends BaseOptions {
+    webpackHelpers: IWebpackHelpers;
+}
+export declare function createNodeWebpackChain({ webpackHelpers, ...baseOptions }: NodeOptions): WebpackChain;

package/lib/webpack/config/node.js

@@ -0,0 +1,55 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const detectTypescript_1 = require("@shuvi/utils/lib/detectTypescript");
+const base_1 = require("./base");
+const external_1 = require("./parts/external");
+const style_1 = require("./parts/style");
+const resolve_1 = require("./parts/resolve");
+function createNodeWebpackChain(_a) {
+    var { webpackHelpers } = _a, baseOptions = __rest(_a, ["webpackHelpers"]);
+    const chain = base_1.baseWebpackChain(baseOptions);
+    const { useTypeScript } = detectTypescript_1.getTypeScriptInfo(baseOptions.projectRoot);
+    chain.target('node');
+    chain.devtool(false);
+    const extensions = [
+        ...(useTypeScript ? ['.tsx', '.ts'] : []),
+        '.js',
+        '.mjs',
+        '.jsx',
+        '.json',
+        '.wasm'
+    ];
+    chain.resolve.extensions.merge(baseOptions.target
+        ? resolve_1.resolvePreferTarget(baseOptions.target, extensions)
+        : extensions);
+    // fix: Can't reexport the named export 'BREAK' from non EcmaScript module
+    // related issue: https://github.com/graphql/graphql-js/issues/1272
+    chain.resolve.mainFields.clear().add('main').add('module');
+    chain.output.libraryTarget('commonjs2');
+    chain.optimization.minimize(false);
+    webpackHelpers.addExternals(chain, external_1.nodeExternals({ projectRoot: baseOptions.projectRoot }));
+    chain.module
+        .rule('main')
+        .oneOf('js')
+        .use('shuvi-babel-loader')
+        .tap(options => (Object.assign(Object.assign({}, options), { isNode: true })));
+    chain.plugin('private/build-manifest').tap(([options]) => [
+        Object.assign(Object.assign({}, options), { modules: false })
+    ]);
+    chain.plugin('define').tap(([options]) => [
+        Object.assign(Object.assign({}, options), { __BROWSER__: false })
+    ]);
+    return style_1.withStyle(chain, { ssr: true });
+}
+exports.createNodeWebpackChain = createNodeWebpackChain;

package/lib/webpack/config/parts/external.d.ts

@@ -0,0 +1,4 @@
+import { ExternalsFunction } from '../../types';
+export declare function nodeExternals({ projectRoot }: {
+    projectRoot: string;
+}): ExternalsFunction;

package/lib/webpack/config/parts/external.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// import resolve from "resolve";
+const constants_1 = require("../../../constants");
+function match(value, tests) {
+    let matched = false;
+    for (let index = 0; index < tests.length; index++) {
+        const test = tests[index];
+        if (typeof test === 'string') {
+            matched = test === value;
+        }
+        else {
+            matched = value.match(test) !== null;
+        }
+        if (matched) {
+            return true;
+        }
+        else {
+            continue;
+        }
+    }
+    return matched;
+}
+function nodeExternals({ projectRoot }) {
+    const nodeExternal = ({ context, request }, next) => {
+        function transpiled() {
+            return next(null, undefined);
+        }
+        function external() {
+            return next(null, `commonjs ${request}`);
+        }
+        const notExternalModules = [];
+        const externalModules = [
+            /@shuvi[/\\]service[/\\]lib[/\\]lib[/\\]runtimeConfig/
+        ];
+        // make sure we don't externalize anything that is
+        // supposed to be transpiled
+        if (match(request, constants_1.AppSourceRegexs)) {
+            return transpiled();
+        }
+        if (match(request, notExternalModules)) {
+            return transpiled();
+        }
+        if (match(request, externalModules)) {
+            return external();
+        }
+        next(null, 'next');
+        // // Relative requires don't need custom resolution, because they
+        // // are relative to requests we've already resolved here.
+        // // Absolute requires (require('/foo')) are extremely uncommon, but
+        // // also have no need for customization as they're already resolved.
+        // const start = request.charAt(0);
+        // if (start === "." || request.startsWith("/")) {
+        //   return transpiled();
+        // }
+        // let res;
+        // try {
+        //   res = resolve.sync(request, { basedir: context });
+        // } catch (err) {
+        //   // If the request cannot be resolved, we need to tell webpack to
+        //   // "bundle" it so that webpack shows an error (that it cannot be
+        //   // resolved).
+        //   return transpiled();
+        // }
+        // if (!res) {
+        //   return transpiled();
+        // }
+        // let baseRes;
+        // try {
+        //   baseRes = resolve.sync(request, { basedir: projectRoot });
+        // } catch (err) {}
+        // if (baseRes !== res) {
+        //   return transpiled();
+        // }
+        // // Webpack itself has to be compiled because it doesn't always use module relative paths
+        // if (
+        //   res.match(/node_modules[/\\]webpack/) ||
+        //   res.match(/node_modules[/\\]css-loader/)
+        // ) {
+        //   return transpiled();
+        // }
+        // // Anything else that is standard JavaScript within `node_modules`
+        // // can be externalized.
+        // if (res.match(/node_modules[/\\].*\.js$/)) {
+        //   return external();
+        // }
+        // transpiled();
+    };
+    return nodeExternal;
+}
+exports.nodeExternals = nodeExternals;

package/lib/webpack/config/parts/helpers.d.ts

@@ -0,0 +1,3 @@
+import { IWebpackHelpers } from '../../types';
+export declare const webpackHelpers: () => IWebpackHelpers;
+export declare function shouldUseRelativeAssetPaths(publicPath: string): boolean;

package/lib/webpack/config/parts/helpers.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webpackHelpers = () => {
+    const externalFns = [];
+    const defaultExternalsFn = ({ context, request }, callback) => {
+        let callbackCalled = false;
+        const nextHandler = (err, result) => {
+            if (err) {
+                callback(err, undefined);
+                callbackCalled = true;
+            }
+            else {
+                if (result !== 'next') {
+                    callback(err, result);
+                    callbackCalled = true;
+                }
+            }
+        };
+        for (let i = 0; i < externalFns.length; i++) {
+            externalFns[i]({ context, request }, nextHandler);
+            if (callbackCalled) {
+                break;
+            }
+        }
+        if (!callbackCalled) {
+            callback(null, undefined);
+        }
+    };
+    return {
+        addExternals: (webpackChain, externalFn) => {
+            let externals = webpackChain.get('externals');
+            if (!externals) {
+                externals = defaultExternalsFn;
+                webpackChain.externals(externals);
+            }
+            if (typeof externals === 'function' &&
+                externals.name === 'defaultExternalsFn') {
+                externalFns.push(externalFn);
+                return;
+            }
+            throw new Error('Externals was modified directly, addExternals will have no effect.');
+        }
+    };
+};
+function shouldUseRelativeAssetPaths(publicPath) {
+    return publicPath === './';
+}
+exports.shouldUseRelativeAssetPaths = shouldUseRelativeAssetPaths;

package/lib/webpack/config/parts/resolve.d.ts

@@ -0,0 +1 @@
+export declare function resolvePreferTarget(target: string, extensions: string[]): string[];

package/lib/webpack/config/parts/resolve.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function resolvePreferTarget(target, extensions) {
+    return extensions.reduce((res, ext) => {
+        res.push(`.${target}${ext}`);
+        res.push(ext);
+        return res;
+    }, []);
+}
+exports.resolvePreferTarget = resolvePreferTarget;

package/lib/webpack/config/parts/style.d.ts

@@ -0,0 +1,9 @@
+import Config from 'webpack-chain';
+interface StyleOptions {
+    publicPath?: string;
+    extractCss?: boolean;
+    sourceMap?: boolean;
+    ssr?: boolean;
+}
+export declare function withStyle(chain: Config, { extractCss, sourceMap, ssr, publicPath }: StyleOptions): Config;
+export {};