gnezim
0a5ab058a6
- Angular 12 application with PrimeNG components - 5 existing Cypress e2e test suites - SCSS styling with BEM naming convention - i18n support (10 languages) - Leaflet map integration - Complete component hierarchy and routing structure This baseline will be used for Angular → React migration.
256 lines
10 KiB
JavaScript
256 lines
10 KiB
JavaScript
"use strict";
|
|
var __webpack_require__ = {};
|
|
(()=>{
|
|
__webpack_require__.n = (module)=>{
|
|
var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
|
|
__webpack_require__.d(getter, {
|
|
a: getter
|
|
});
|
|
return getter;
|
|
};
|
|
})();
|
|
(()=>{
|
|
__webpack_require__.d = (exports1, definition)=>{
|
|
for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
|
|
enumerable: true,
|
|
get: definition[key]
|
|
});
|
|
};
|
|
})();
|
|
(()=>{
|
|
__webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
|
|
})();
|
|
(()=>{
|
|
__webpack_require__.r = (exports1)=>{
|
|
if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
|
|
value: 'Module'
|
|
});
|
|
Object.defineProperty(exports1, '__esModule', {
|
|
value: true
|
|
});
|
|
};
|
|
})();
|
|
var __webpack_exports__ = {};
|
|
__webpack_require__.r(__webpack_exports__);
|
|
__webpack_require__.d(__webpack_exports__, {
|
|
ReactRefreshRspackPlugin: ()=>ReactRefreshRspackPlugin,
|
|
default: ()=>src
|
|
});
|
|
const external_node_path_namespaceObject = require("node:path");
|
|
var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
|
|
const d = (object, property, defaultValue)=>{
|
|
if (void 0 === object[property] && void 0 !== defaultValue) object[property] = defaultValue;
|
|
return object[property];
|
|
};
|
|
const normalizeOverlay = (options)=>{
|
|
const defaultOverlay = {
|
|
entry: external_node_path_default().join(__dirname, '../client/errorOverlayEntry.js'),
|
|
module: external_node_path_default().join(__dirname, '../client/overlay/index.js'),
|
|
sockIntegration: 'wds'
|
|
};
|
|
if (!options) return false;
|
|
if (void 0 === options || true === options) return defaultOverlay;
|
|
options.entry = options.entry ?? defaultOverlay.entry;
|
|
options.module = options.module ?? defaultOverlay.module;
|
|
options.sockIntegration = options.sockIntegration ?? defaultOverlay.sockIntegration;
|
|
return options;
|
|
};
|
|
function normalizeOptions(options) {
|
|
d(options, 'exclude', /node_modules/i);
|
|
d(options, 'include', /\.([cm]js|[jt]sx?|flow)$/i);
|
|
d(options, 'library');
|
|
d(options, 'forceEnable', false);
|
|
d(options, 'injectLoader', true);
|
|
d(options, 'injectEntry', true);
|
|
d(options, 'reloadOnRuntimeErrors', false);
|
|
d(options, 'reactRefreshLoader', 'builtin:react-refresh-loader');
|
|
options.overlay = normalizeOverlay(options.overlay);
|
|
return options;
|
|
}
|
|
const reactRefreshPath = external_node_path_default().join(__dirname, '../client/reactRefresh.js');
|
|
const reactRefreshEntryPath = external_node_path_default().join(__dirname, '../client/reactRefreshEntry.js');
|
|
const refreshUtilsPath = external_node_path_default().join(__dirname, '../client/refreshUtils.js');
|
|
let refreshRuntimeDirPath;
|
|
function getRefreshRuntimeDirPath() {
|
|
if (!refreshRuntimeDirPath) refreshRuntimeDirPath = external_node_path_default().dirname(require.resolve('react-refresh', {
|
|
paths: [
|
|
reactRefreshPath
|
|
]
|
|
}));
|
|
return refreshRuntimeDirPath;
|
|
}
|
|
const getRefreshRuntimePaths = ()=>[
|
|
reactRefreshEntryPath,
|
|
reactRefreshPath,
|
|
refreshUtilsPath,
|
|
getRefreshRuntimeDirPath()
|
|
];
|
|
const external_node_querystring_namespaceObject = require("node:querystring");
|
|
var external_node_querystring_default = /*#__PURE__*/ __webpack_require__.n(external_node_querystring_namespaceObject);
|
|
function getAdditionalEntries({ devServer, options }) {
|
|
const resourceQuery = {};
|
|
if (devServer) {
|
|
const { client, https, http2, sockHost, sockPath, sockPort } = devServer;
|
|
let { host, path, port } = devServer;
|
|
let protocol = https || http2 ? 'https' : 'http';
|
|
if (sockHost) host = sockHost;
|
|
if (sockPath) path = sockPath;
|
|
if (sockPort) port = sockPort;
|
|
if (client && null != client.webSocketURL) {
|
|
let parsedUrl = client.webSocketURL;
|
|
if ('string' == typeof parsedUrl) parsedUrl = new URL(parsedUrl);
|
|
let auth;
|
|
if (parsedUrl.username) {
|
|
auth = parsedUrl.username;
|
|
if (parsedUrl.password) auth += `:${parsedUrl.password}`;
|
|
}
|
|
if (null != parsedUrl.hostname) host = [
|
|
null != auth && auth,
|
|
parsedUrl.hostname
|
|
].filter(Boolean).join('@');
|
|
if (null != parsedUrl.pathname) path = parsedUrl.pathname;
|
|
if (null != parsedUrl.port) port = [
|
|
'0',
|
|
'auto'
|
|
].includes(String(parsedUrl.port)) ? void 0 : parsedUrl.port;
|
|
if (null != parsedUrl.protocol) protocol = 'auto' !== parsedUrl.protocol ? parsedUrl.protocol.replace(':', '') : 'ws';
|
|
}
|
|
if (host) resourceQuery.sockHost = host;
|
|
if (path) resourceQuery.sockPath = path;
|
|
if (port) resourceQuery.sockPort = port;
|
|
resourceQuery.sockProtocol = protocol;
|
|
}
|
|
if (options.overlay) {
|
|
const { sockHost, sockPath, sockPort, sockProtocol } = options.overlay;
|
|
if (sockHost) resourceQuery.sockHost = sockHost;
|
|
if (sockPath) resourceQuery.sockPath = sockPath;
|
|
if (sockPort) resourceQuery.sockPort = sockPort;
|
|
if (sockProtocol) resourceQuery.sockProtocol = sockProtocol;
|
|
}
|
|
const queryString = external_node_querystring_default().stringify(resourceQuery, void 0, void 0, {
|
|
encodeURIComponent (str) {
|
|
return str;
|
|
}
|
|
});
|
|
const prependEntries = [
|
|
reactRefreshEntryPath
|
|
];
|
|
const overlayEntries = [
|
|
false !== options.overlay && options.overlay?.entry && `${require.resolve(options.overlay.entry)}${queryString ? `?${queryString}` : ''}`
|
|
].filter(Boolean);
|
|
return {
|
|
prependEntries,
|
|
overlayEntries
|
|
};
|
|
}
|
|
function getIntegrationEntry(integrationType) {
|
|
let resolvedEntry;
|
|
switch(integrationType){
|
|
case 'whm':
|
|
resolvedEntry = 'webpack-hot-middleware/client';
|
|
break;
|
|
}
|
|
return resolvedEntry;
|
|
}
|
|
function getSocketIntegration(integrationType) {
|
|
let resolvedSocketIntegration;
|
|
switch(integrationType){
|
|
case 'wds':
|
|
resolvedSocketIntegration = external_node_path_default().join(__dirname, './sockets/WDSSocket.js');
|
|
break;
|
|
case 'whm':
|
|
resolvedSocketIntegration = external_node_path_default().join(__dirname, './sockets/WHMEventSource.js');
|
|
break;
|
|
default:
|
|
resolvedSocketIntegration = require.resolve(integrationType);
|
|
break;
|
|
}
|
|
return resolvedSocketIntegration;
|
|
}
|
|
function addEntry(entry, compiler) {
|
|
new compiler.rspack.EntryPlugin(compiler.context, entry, {
|
|
name: void 0
|
|
}).apply(compiler);
|
|
}
|
|
function addSocketEntry(sockIntegration, compiler) {
|
|
const integrationEntry = getIntegrationEntry(sockIntegration);
|
|
if (integrationEntry) addEntry(integrationEntry, compiler);
|
|
}
|
|
const PLUGIN_NAME = 'ReactRefreshRspackPlugin';
|
|
class ReactRefreshRspackPlugin {
|
|
options;
|
|
static get deprecated_runtimePaths() {
|
|
return getRefreshRuntimePaths();
|
|
}
|
|
constructor(options = {}){
|
|
this.options = normalizeOptions(options);
|
|
}
|
|
apply(compiler) {
|
|
if (('development' !== compiler.options.mode || process.env.NODE_ENV && 'production' === process.env.NODE_ENV) && !this.options.forceEnable) return;
|
|
const addEntries = getAdditionalEntries({
|
|
devServer: compiler.options.devServer,
|
|
options: this.options
|
|
});
|
|
if (this.options.injectEntry) for (const entry of addEntries.prependEntries)addEntry(entry, compiler);
|
|
if (false !== this.options.overlay && this.options.overlay.sockIntegration) addSocketEntry(this.options.overlay.sockIntegration, compiler);
|
|
for (const entry of addEntries.overlayEntries)addEntry(entry, compiler);
|
|
new compiler.rspack.ProvidePlugin({
|
|
$ReactRefreshRuntime$: reactRefreshPath
|
|
}).apply(compiler);
|
|
if (this.options.injectLoader) compiler.options.module.rules.unshift({
|
|
test: this.options.test,
|
|
include: this.options.include,
|
|
exclude: {
|
|
or: [
|
|
this.options.exclude,
|
|
[
|
|
...getRefreshRuntimePaths()
|
|
]
|
|
].filter(Boolean)
|
|
},
|
|
resourceQuery: this.options.resourceQuery,
|
|
dependency: {
|
|
not: [
|
|
'url'
|
|
]
|
|
},
|
|
use: this.options.reactRefreshLoader
|
|
});
|
|
const definedModules = {
|
|
__react_refresh_library__: JSON.stringify(compiler.rspack.Template.toIdentifier(this.options.library || compiler.options.output.uniqueName || compiler.options.output.library)),
|
|
__reload_on_runtime_errors__: this.options.reloadOnRuntimeErrors
|
|
};
|
|
const providedModules = {
|
|
__react_refresh_utils__: refreshUtilsPath
|
|
};
|
|
if (false === this.options.overlay) {
|
|
definedModules.__react_refresh_error_overlay__ = false;
|
|
definedModules.__react_refresh_socket__ = false;
|
|
} else {
|
|
if (this.options.overlay.module) providedModules.__react_refresh_error_overlay__ = require.resolve(this.options.overlay.module);
|
|
if (this.options.overlay.sockIntegration) providedModules.__react_refresh_socket__ = getSocketIntegration(this.options.overlay.sockIntegration);
|
|
}
|
|
new compiler.rspack.DefinePlugin(definedModules).apply(compiler);
|
|
new compiler.rspack.ProvidePlugin(providedModules).apply(compiler);
|
|
compiler.options.resolve.alias = {
|
|
'react-refresh': getRefreshRuntimeDirPath(),
|
|
...compiler.options.resolve.alias
|
|
};
|
|
compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation)=>{
|
|
compilation.hooks.additionalTreeRuntimeRequirements.tap(PLUGIN_NAME, (_, runtimeRequirements)=>{
|
|
runtimeRequirements.add(compiler.rspack.RuntimeGlobals.moduleCache);
|
|
});
|
|
});
|
|
}
|
|
}
|
|
const src = ReactRefreshRspackPlugin;
|
|
exports.ReactRefreshRspackPlugin = __webpack_exports__.ReactRefreshRspackPlugin;
|
|
exports["default"] = __webpack_exports__["default"];
|
|
for(var __webpack_i__ in __webpack_exports__)if (-1 === [
|
|
"ReactRefreshRspackPlugin",
|
|
"default"
|
|
].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
|
|
Object.defineProperty(exports, '__esModule', {
|
|
value: true
|
|
});
|