@rspack/core 1.0.0-alpha.5 → 1.0.0-beta.1

package/dist/stats/DefaultStatsPrinterPlugin.js

@@ -19,7 +19,7 @@ const printSizes = (sizes, { formatSize = (n) => `${n}` }) => {
     if (keys.length > 1) {
         return keys.map(key => `${formatSize(sizes[key])} (${key})`).join(" ");
     }
-    else if (keys.length === 1) {
+    if (keys.length === 1) {
         return formatSize(sizes[keys[0]]);
     }
 };
@@ -242,9 +242,7 @@ const SIMPLE_PRINTERS = {
                     providedExportsCount === usedExports.length) {
                     return cyan(formatFlag("all exports used"));
                 }
-                else {
-                    return cyan(formatFlag(`only some exports used: ${usedExports.join(", ")}`));
-                }
+                return cyan(formatFlag(`only some exports used: ${usedExports.join(", ")}`));
             }
         }
     },
@@ -909,23 +907,20 @@ const AVAILABLE_FORMATS = {
             ];
             if (time < times[3])
                 return `${time}${unit}`;
-            else if (time < times[2])
+            if (time < times[2])
                 return bold(`${time}${unit}`);
-            else if (time < times[1])
+            if (time < times[1])
                 return green(`${time}${unit}`);
-            else if (time < times[0])
+            if (time < times[0])
                 return yellow(`${time}${unit}`);
-            else
-                return red(`${time}${unit}`);
+            return red(`${time}${unit}`);
         }
-        else {
-            let timeStr = time.toString();
-            if (time > 1000) {
-                timeStr = `${(time / 1000).toFixed(2)}`;
-                unit = " s";
-            }
-            return `${boldQuantity ? bold(timeStr) : timeStr}${unit}`;
+        let timeStr = time.toString();
+        if (time > 1000) {
+            timeStr = `${(time / 1000).toFixed(2)}`;
+            unit = " s";
         }
+        return `${boldQuantity ? bold(timeStr) : timeStr}${unit}`;
     },
     formatError: (msg, { green, yellow, red }) => {
         let message = msg;

package/dist/stats/StatsFactory.js

@@ -98,16 +98,14 @@ class StatsFactory {
         if (this._inCreate) {
             return this._create(type, data, baseContext);
         }
-        else {
-            try {
-                this._inCreate = true;
-                return this._create(type, data, baseContext);
-            }
-            finally {
-                for (const key of Object.keys(this._caches))
-                    this._caches[key].clear();
-                this._inCreate = false;
-            }
+        try {
+            this._inCreate = true;
+            return this._create(type, data, baseContext);
+        }
+        finally {
+            for (const key of Object.keys(this._caches))
+                this._caches[key].clear();
+            this._inCreate = false;
         }
     }
     _create(type, data, baseContext) {
@@ -168,13 +166,11 @@ class StatsFactory {
             // run result on merged items
             return this._forEachLevelWaterfall(this.hooks.result, this._caches.result, type, result, (h, r) => h.call(r, context));
         }
-        else {
-            const object = {};
-            // run extract on value
-            this._forEachLevel(this.hooks.extract, this._caches.extract, type, h => h.call(object, data, context));
-            // run result on extracted object
-            return this._forEachLevelWaterfall(this.hooks.result, this._caches.result, type, object, (h, r) => h.call(r, context));
-        }
+        const object = {};
+        // run extract on value
+        this._forEachLevel(this.hooks.extract, this._caches.extract, type, h => h.call(object, data, context));
+        // run result on extracted object
+        return this._forEachLevelWaterfall(this.hooks.result, this._caches.result, type, object, (h, r) => h.call(r, context));
     }
 }
 exports.StatsFactory = StatsFactory;

package/dist/stats/StatsPrinter.js

@@ -80,15 +80,13 @@ class StatsPrinter {
         if (this._inPrint) {
             return this._print(type, object, baseContext);
         }
-        else {
-            try {
-                this._inPrint = true;
-                return this._print(type, object, baseContext);
-            }
-            finally {
-                this._levelHookCache.clear();
-                this._inPrint = false;
-            }
+        try {
+            this._inPrint = true;
+            return this._print(type, object, baseContext);
+        }
+        finally {
+            this._levelHookCache.clear();
+            this._inPrint = false;
         }
     }
     _print(type, object, baseContext) {

package/dist/util/AssetInfo.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.JsAssetInfo = void 0;
 class JsAssetInfo {
     static __from_binding(jsAssetInfo) {
-        const { immutable, minimized, development, hotModuleReplacement, related, chunkHash, contentHash, javascriptModule, sourceFilename, extras } = jsAssetInfo;
+        const { immutable, minimized, development, hotModuleReplacement, related, chunkhash, fullhash, contenthash, javascriptModule, sourceFilename, extras } = jsAssetInfo;
         return {
             ...extras,
             immutable,
@@ -11,14 +11,15 @@ class JsAssetInfo {
             development,
             hotModuleReplacement,
             related,
-            chunkHash,
-            contentHash,
+            fullhash,
+            chunkhash,
+            contenthash,
             javascriptModule,
             sourceFilename
         };
     }
     static __to_binding(assetInfo = {}) {
-        let { immutable = false, minimized = false, development = false, hotModuleReplacement = false, related = {}, chunkHash = [], contentHash = [], javascriptModule, sourceFilename, ...extras } = assetInfo;
+        let { immutable = false, minimized = false, development = false, hotModuleReplacement = false, related = {}, fullhash = [], chunkhash = [], contenthash = [], javascriptModule, sourceFilename, ...extras } = assetInfo;
         extras = extras ?? {};
         return {
             immutable,
@@ -26,9 +27,12 @@ class JsAssetInfo {
             development,
             hotModuleReplacement,
             related,
-            chunkHash,
-            contentHash,
-            extras
+            fullhash,
+            chunkhash,
+            contenthash,
+            extras,
+            javascriptModule,
+            sourceFilename
         };
     }
 }

package/dist/util/SplitChunkSize.js

@@ -6,7 +6,7 @@ class JsSplitChunkSizes {
         if (typeof sizes === "number") {
             return sizes;
         }
-        else if (sizes && typeof sizes === "object") {
+        if (sizes && typeof sizes === "object") {
             const chunkSizes = {
                 sizes: sizes
             };

package/dist/util/cleverMerge.d.ts

@@ -1,42 +1,16 @@
-export type ObjectParsedPropertyEntry = {
-    /**
-     * base value
-     */
-    base: any | undefined;
-    /**
-     * the name of the selector property
-     */
-    byProperty: string | undefined;
-    /**
-     * value depending on selector property, merged with base
-     */
-    byValues: Map<string, any>;
-};
-export type ParsedObject = {
-    /**
-     * static properties (key is property name)
-     */
-    static: Map<string, ObjectParsedPropertyEntry>;
-    /**
-     * dynamic part
-     */
-    dynamic: {
-        byProperty: string;
-        fn: Function;
-    } | undefined;
-};
 /**
- * @template T
- * @param {Partial<T>} obj object
- * @param {string} property property
- * @param {string|number|boolean} value assignment value
- * @returns {T} new object
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/util/cleverMerge.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
  */
-export function cachedSetProperty<T>(obj: Partial<T>, property: string, value: string | number | boolean): T;
+type Obj = Record<PropertyKey, any>;
+export declare const DELETE: unique symbol;
 /**
  * Merges two given objects and caches the result to avoid computation if same objects passed as arguments again.
- * @template T
- * @template O
  * @example
  * // performs cleverMerge(first, second), stores the result in WeakMap and returns result
  * cachedCleverMerge({a: 1}, {a: 2})
@@ -44,35 +18,37 @@ export function cachedSetProperty<T>(obj: Partial<T>, property: string, value: s
  *  // when same arguments passed, gets the result from WeakMap and returns it.
  * cachedCleverMerge({a: 1}, {a: 2})
  * {a: 2}
- * @param {T} first first object
- * @param {O} second second object
- * @returns {T & O | T | O} merged object of first and second object
+ * @param first first object
+ * @param second second object
+ * @returns  merged object of first and second object
  */
-export function cachedCleverMerge<T, O>(first: T, second: O): T | O | (T & O);
+export declare const cachedCleverMerge: <First, Second>(first: First, second: Second) => First | Second | (First & Second);
+/**
+ * @param obj object
+ * @param property property
+ * @param value assignment value
+ * @returns new object
+ */
+export declare const cachedSetProperty: (obj: Obj, property: string, value: string | number | boolean) => Obj;
 /**
  * Merges two objects. Objects are deeply clever merged.
  * Arrays might reference the old value with "...".
  * Non-object values take preference over object values.
- * @template T
- * @template O
- * @param {T} first first object
- * @param {O} second second object
- * @returns {T & O | T | O} merged object of first and second object
+ * @param first first object
+ * @param second second object
+ * @returns merged object of first and second object
  */
-export function cleverMerge<T, O>(first: T, second: O): T | O | (T & O);
+export declare const cleverMerge: <First, Second>(first: First, second: Second) => First | Second | (First & Second);
 /**
- * @template T
- * @template {string} P
- * @param {T} obj the object
- * @param {P} byProperty the by description
- * @param  {...any} values values
- * @returns {Omit<T, P>|undefined} object with merged byProperty
+ * @param obj the object
+ * @returns the object without operations like "..." or DELETE
  */
-export function resolveByProperty<T, P extends string>(obj: T, byProperty: P, ...values: any[]): Omit<T, P> | undefined;
+export declare const removeOperations: <O extends Obj>(obj: O) => O;
 /**
- * @template T
- * @param {T} obj the object
- * @returns {T} the object without operations like "..." or DELETE
+ * @param obj the object
+ * @param byProperty the by description
+ * @param values values
+ * @returns object with merged byProperty
  */
-export function removeOperations<T>(obj: T): T;
-export const DELETE: unique symbol;
+export declare const resolveByProperty: <O extends Obj | null, P extends PropertyKey>(obj: O, byProperty: P, ...values: any[]) => Omit<O, P> | undefined;
+export {};