@rspack/core 1.0.0-rc.0 → 1.0.0-rc.2

package/compiled/zod-validation-error/index.d.ts

@@ -1,22 +1,41 @@
 import * as zod from 'zod';
 
+interface ErrorOptions {
+    cause?: unknown;
+}
 declare class ValidationError extends Error {
-    details: Array<zod.ZodIssue>;
     name: 'ZodValidationError';
-    constructor(message: string, details?: Array<zod.ZodIssue> | undefined);
+    details: Array<zod.ZodIssue>;
+    constructor(message?: string, options?: ErrorOptions);
     toString(): string;
 }
-type ZodError = zod.ZodError;
-type FromZodErrorOptions = {
-    maxIssuesInMessage?: number;
+
+declare function isValidationError(err: unknown): err is ValidationError;
+
+declare function isValidationErrorLike(err: unknown): err is ValidationError;
+
+declare function isZodErrorLike(err: unknown): err is zod.ZodError;
+
+declare const errorMap: zod.ZodErrorMap;
+
+type ZodIssue = zod.ZodIssue;
+type FromZodIssueOptions = {
     issueSeparator?: string;
     unionSeparator?: string;
+    prefix?: string | null;
     prefixSeparator?: string;
-    prefix?: string;
+    includePath?: boolean;
+};
+declare function fromZodIssue(issue: ZodIssue, options?: FromZodIssueOptions): ValidationError;
+
+type ZodError = zod.ZodError;
+type FromZodErrorOptions = FromZodIssueOptions & {
+    maxIssuesInMessage?: number;
 };
 declare function fromZodError(zodError: ZodError, options?: FromZodErrorOptions): ValidationError;
-declare const toValidationError: (options?: Parameters<typeof fromZodError>[1]) => (err: unknown) => ValidationError | Error;
-declare function isValidationError(err: unknown): err is ValidationError;
-declare function isValidationErrorLike(err: unknown): err is ValidationError;
 
-export { type FromZodErrorOptions, ValidationError, type ZodError, fromZodError, isValidationError, isValidationErrorLike, toValidationError };
+declare function fromError(err: unknown, options?: FromZodErrorOptions): ValidationError;
+
+declare const toValidationError: (options?: Parameters<typeof fromZodError>[1]) => (err: unknown) => ValidationError;
+
+export { type ErrorOptions, type FromZodErrorOptions, type FromZodIssueOptions, ValidationError, type ZodError, type ZodIssue, errorMap, fromError, fromZodError, fromZodIssue, isValidationError, isValidationErrorLike, isZodErrorLike, toValidationError };

package/compiled/zod-validation-error/index.js

@@ -2,152 +2,280 @@
 /******/ 	"use strict";
 /******/ 	var __webpack_modules__ = ({
 
-/***/ 381:
-/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+/***/ 172:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.isValidationErrorLike = exports.isValidationError = exports.toValidationError = exports.fromZodError = exports.ValidationError = void 0;
-const zod = __importStar(__nccwpck_require__(934));
-const joinPath_1 = __nccwpck_require__(954);
-const NonEmptyArray_1 = __nccwpck_require__(978);
-class ValidationError extends Error {
-    details;
-    name;
-    constructor(message, details = []) {
-        super(message);
-        this.details = details;
-        this.name = 'ZodValidationError';
-    }
-    toString() {
-        return this.message;
-    }
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// lib/index.ts
+var lib_exports = {};
+__export(lib_exports, {
+  ValidationError: () => ValidationError,
+  errorMap: () => errorMap,
+  fromError: () => fromError,
+  fromZodError: () => fromZodError,
+  fromZodIssue: () => fromZodIssue,
+  isValidationError: () => isValidationError,
+  isValidationErrorLike: () => isValidationErrorLike,
+  isZodErrorLike: () => isZodErrorLike,
+  toValidationError: () => toValidationError
+});
+module.exports = __toCommonJS(lib_exports);
+
+// lib/isZodErrorLike.ts
+function isZodErrorLike(err) {
+  return err instanceof Error && err.name === "ZodError" && "issues" in err && Array.isArray(err.issues);
 }
-exports.ValidationError = ValidationError;
-function fromZodIssue(issue, issueSeparator, unionSeparator) {
-    if (issue.code === 'invalid_union') {
-        return issue.unionErrors
-            .reduce((acc, zodError) => {
-            const newIssues = zodError.issues
-                .map((issue) => fromZodIssue(issue, issueSeparator, unionSeparator))
-                .join(issueSeparator);
-            if (!acc.includes(newIssues)) {
-                acc.push(newIssues);
-            }
-            return acc;
-        }, [])
-            .join(unionSeparator);
-    }
-    if ((0, NonEmptyArray_1.isNonEmptyArray)(issue.path)) {
-        if (issue.path.length === 1) {
-            const identifier = issue.path[0];
-            if (typeof identifier === 'number') {
-                return `${issue.message} at index ${identifier}`;
-            }
-        }
-        return `${issue.message} at "${(0, joinPath_1.joinPath)(issue.path)}"`;
+
+// lib/ValidationError.ts
+var ValidationError = class extends Error {
+  name;
+  details;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ZodValidationError";
+    this.details = getIssuesFromErrorOptions(options);
+  }
+  toString() {
+    return this.message;
+  }
+};
+function getIssuesFromErrorOptions(options) {
+  if (options) {
+    const cause = options.cause;
+    if (isZodErrorLike(cause)) {
+      return cause.issues;
     }
-    return issue.message;
+  }
+  return [];
 }
-function fromZodError(zodError, options = {}) {
-    const { maxIssuesInMessage = 99, issueSeparator = '; ', unionSeparator = ', or ', prefixSeparator = ': ', prefix = 'Validation error', } = options;
-    const reason = zodError.errors
-        .slice(0, maxIssuesInMessage)
-        .map((issue) => fromZodIssue(issue, issueSeparator, unionSeparator))
-        .join(issueSeparator);
-    const message = reason ? [prefix, reason].join(prefixSeparator) : prefix;
-    return new ValidationError(message, zodError.errors);
-}
-exports.fromZodError = fromZodError;
-const toValidationError = (options = {}) => (err) => {
-    if (err instanceof zod.ZodError) {
-        return fromZodError(err, options);
-    }
-    if (err instanceof Error) {
-        return err;
-    }
-    return new Error('Unknown error');
-};
-exports.toValidationError = toValidationError;
+
+// lib/isValidationError.ts
 function isValidationError(err) {
-    return err instanceof ValidationError;
+  return err instanceof ValidationError;
 }
-exports.isValidationError = isValidationError;
+
+// lib/isValidationErrorLike.ts
 function isValidationErrorLike(err) {
-    return err instanceof Error && err.name === 'ZodValidationError';
+  return err instanceof Error && err.name === "ZodValidationError";
 }
-exports.isValidationErrorLike = isValidationErrorLike;
 
+// lib/fromZodIssue.ts
+var zod = __toESM(__nccwpck_require__(934));
 
-/***/ }),
+// lib/config.ts
+var ISSUE_SEPARATOR = "; ";
+var MAX_ISSUES_IN_MESSAGE = 99;
+var PREFIX = "Validation error";
+var PREFIX_SEPARATOR = ": ";
+var UNION_SEPARATOR = ", or ";
 
-/***/ 978:
-/***/ ((__unused_webpack_module, exports) => {
+// lib/prefixMessage.ts
+function prefixMessage(message, prefix, prefixSeparator) {
+  if (prefix !== null) {
+    if (message.length > 0) {
+      return [prefix, message].join(prefixSeparator);
+    }
+    return prefix;
+  }
+  if (message.length > 0) {
+    return message;
+  }
+  return PREFIX;
+}
 
+// lib/utils/joinPath.ts
+var identifierRegex = /[$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*/u;
+function joinPath(path) {
+  if (path.length === 1) {
+    return path[0].toString();
+  }
+  return path.reduce((acc, item) => {
+    if (typeof item === "number") {
+      return acc + "[" + item.toString() + "]";
+    }
+    if (item.includes('"')) {
+      return acc + '["' + escapeQuotes(item) + '"]';
+    }
+    if (!identifierRegex.test(item)) {
+      return acc + '["' + item + '"]';
+    }
+    const separator = acc.length === 0 ? "" : ".";
+    return acc + separator + item;
+  }, "");
+}
+function escapeQuotes(str) {
+  return str.replace(/"/g, '\\"');
+}
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.isNonEmptyArray = void 0;
+// lib/utils/NonEmptyArray.ts
 function isNonEmptyArray(value) {
-    return value.length !== 0;
+  return value.length !== 0;
 }
-exports.isNonEmptyArray = isNonEmptyArray;
 
+// lib/fromZodIssue.ts
+function getMessageFromZodIssue(props) {
+  const { issue, issueSeparator, unionSeparator, includePath } = props;
+  if (issue.code === "invalid_union") {
+    return issue.unionErrors.reduce((acc, zodError) => {
+      const newIssues = zodError.issues.map(
+        (issue2) => getMessageFromZodIssue({
+          issue: issue2,
+          issueSeparator,
+          unionSeparator,
+          includePath
+        })
+      ).join(issueSeparator);
+      if (!acc.includes(newIssues)) {
+        acc.push(newIssues);
+      }
+      return acc;
+    }, []).join(unionSeparator);
+  }
+  if (issue.code === "invalid_arguments") {
+    return [
+      issue.message,
+      ...issue.argumentsError.issues.map(
+        (issue2) => getMessageFromZodIssue({
+          issue: issue2,
+          issueSeparator,
+          unionSeparator,
+          includePath
+        })
+      )
+    ].join(issueSeparator);
+  }
+  if (issue.code === "invalid_return_type") {
+    return [
+      issue.message,
+      ...issue.returnTypeError.issues.map(
+        (issue2) => getMessageFromZodIssue({
+          issue: issue2,
+          issueSeparator,
+          unionSeparator,
+          includePath
+        })
+      )
+    ].join(issueSeparator);
+  }
+  if (includePath && isNonEmptyArray(issue.path)) {
+    if (issue.path.length === 1) {
+      const identifier = issue.path[0];
+      if (typeof identifier === "number") {
+        return `${issue.message} at index ${identifier}`;
+      }
+    }
+    return `${issue.message} at "${joinPath(issue.path)}"`;
+  }
+  return issue.message;
+}
+function fromZodIssue(issue, options = {}) {
+  const {
+    issueSeparator = ISSUE_SEPARATOR,
+    unionSeparator = UNION_SEPARATOR,
+    prefixSeparator = PREFIX_SEPARATOR,
+    prefix = PREFIX,
+    includePath = true
+  } = options;
+  const reason = getMessageFromZodIssue({
+    issue,
+    issueSeparator,
+    unionSeparator,
+    includePath
+  });
+  const message = prefixMessage(reason, prefix, prefixSeparator);
+  return new ValidationError(message, { cause: new zod.ZodError([issue]) });
+}
 
-/***/ }),
-
-/***/ 954:
-/***/ ((__unused_webpack_module, exports) => {
-
+// lib/errorMap.ts
+var errorMap = (issue, ctx) => {
+  const error = fromZodIssue({
+    ...issue,
+    // fallback to the default error message
+    // when issue does not have a message
+    message: issue.message ?? ctx.defaultError
+  });
+  return {
+    message: error.message
+  };
+};
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.joinPath = void 0;
-const identifierRegex = /[$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*/u;
-function joinPath(path) {
-    if (path.length === 1) {
-        return path[0].toString();
-    }
-    return path.reduce((acc, item) => {
-        if (typeof item === 'number') {
-            return acc + '[' + item.toString() + ']';
-        }
-        if (item.includes('"')) {
-            return acc + '["' + escapeQuotes(item) + '"]';
-        }
-        if (!identifierRegex.test(item)) {
-            return acc + '["' + item + '"]';
-        }
-        const separator = acc.length === 0 ? '' : '.';
-        return acc + separator + item;
-    }, '');
+// lib/fromZodError.ts
+function fromZodError(zodError, options = {}) {
+  if (!isZodErrorLike(zodError)) {
+    throw new TypeError(
+      `Invalid zodError param; expected instance of ZodError. Did you mean to use the "${fromError.name}" method instead?`
+    );
+  }
+  return fromZodErrorWithoutRuntimeCheck(zodError, options);
 }
-exports.joinPath = joinPath;
-function escapeQuotes(str) {
-    return str.replace(/"/g, '\\"');
+function fromZodErrorWithoutRuntimeCheck(zodError, options = {}) {
+  const {
+    maxIssuesInMessage = MAX_ISSUES_IN_MESSAGE,
+    issueSeparator = ISSUE_SEPARATOR,
+    unionSeparator = UNION_SEPARATOR,
+    prefixSeparator = PREFIX_SEPARATOR,
+    prefix = PREFIX,
+    includePath = true
+  } = options;
+  const zodIssues = zodError.errors;
+  const reason = zodIssues.length === 0 ? zodError.message : zodIssues.slice(0, maxIssuesInMessage).map(
+    (issue) => getMessageFromZodIssue({
+      issue,
+      issueSeparator,
+      unionSeparator,
+      includePath
+    })
+  ).join(issueSeparator);
+  const message = prefixMessage(reason, prefix, prefixSeparator);
+  return new ValidationError(message, { cause: zodError });
 }
 
+// lib/toValidationError.ts
+var toValidationError = (options = {}) => (err) => {
+  if (isZodErrorLike(err)) {
+    return fromZodErrorWithoutRuntimeCheck(err, options);
+  }
+  if (err instanceof Error) {
+    return new ValidationError(err.message, { cause: err });
+  }
+  return new ValidationError("Unknown error");
+};
+
+// lib/fromError.ts
+function fromError(err, options = {}) {
+  return toValidationError(options)(err);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
+//# sourceMappingURL=index.js.map
 
 /***/ }),
 
@@ -180,7 +308,7 @@ module.exports = require("../zod");
 /******/ 		// Execute the module function
 /******/ 		var threw = true;
 /******/ 		try {
-/******/ 			__webpack_modules__[moduleId].call(module.exports, module, module.exports, __nccwpck_require__);
+/******/ 			__webpack_modules__[moduleId](module, module.exports, __nccwpck_require__);
 /******/ 			threw = false;
 /******/ 		} finally {
 /******/ 			if(threw) delete __webpack_module_cache__[moduleId];
@@ -196,22 +324,12 @@ module.exports = require("../zod");
 /******/ 	if (typeof __nccwpck_require__ !== 'undefined') __nccwpck_require__.ab = __dirname + "/";
 /******/ 	
 /************************************************************************/
-var __webpack_exports__ = {};
-// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
-(() => {
-var exports = __webpack_exports__;
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.fromZodError = exports.isValidationErrorLike = exports.isValidationError = exports.toValidationError = exports.ValidationError = void 0;
-var ValidationError_1 = __nccwpck_require__(381);
-Object.defineProperty(exports, "ValidationError", ({ enumerable: true, get: function () { return ValidationError_1.ValidationError; } }));
-Object.defineProperty(exports, "toValidationError", ({ enumerable: true, get: function () { return ValidationError_1.toValidationError; } }));
-Object.defineProperty(exports, "isValidationError", ({ enumerable: true, get: function () { return ValidationError_1.isValidationError; } }));
-Object.defineProperty(exports, "isValidationErrorLike", ({ enumerable: true, get: function () { return ValidationError_1.isValidationErrorLike; } }));
-Object.defineProperty(exports, "fromZodError", ({ enumerable: true, get: function () { return ValidationError_1.fromZodError; } }));
-
-})();
-
-module.exports = __webpack_exports__;
+/******/ 	
+/******/ 	// startup
+/******/ 	// Load entry module and return exports
+/******/ 	// This entry module is referenced by other modules so it can't be inlined
+/******/ 	var __webpack_exports__ = __nccwpck_require__(172);
+/******/ 	module.exports = __webpack_exports__;
+/******/ 	
 /******/ })()
 ;

package/compiled/zod-validation-error/package.json

@@ -1 +1 @@
-{"name":"zod-validation-error","author":{"name":"Causaly Team","email":"front-end@causaly.com","url":"https://www.causaly.com"},"version":"1.3.1","license":"MIT","types":"index.d.ts","type":"commonjs"}
+{"name":"zod-validation-error","author":{"name":"Dimitrios C. Michalakos","email":"dimitris@jmike.gr","url":"https://github.com/jmike"},"version":"3.3.1","license":"MIT","types":"index.d.ts","type":"commonjs"}

package/dist/config/adapter.js

@@ -650,8 +650,10 @@ function getRawExperiments(experiments) {
         rspackFuture: getRawRspackFutureOptions(rspackFuture)
     };
 }
-function getRawRspackFutureOptions(_future) {
-    return {};
+function getRawRspackFutureOptions(future) {
+    return {
+        newIncremental: future.newIncremental
+    };
 }
 function getRawNode(node) {
     if (node === false) {

package/dist/config/defaults.js

@@ -136,6 +136,9 @@ const applyExperimentsDefaults = (experiments) => {
     // IGNORE(experiments.rspackFuture): Rspack specific configuration
     D(experiments, "rspackFuture", {});
     // rspackFuture.bundlerInfo default value is applied after applyDefaults
+    if (typeof experiments.rspackFuture === "object") {
+        D(experiments.rspackFuture, "newIncremental", false);
+    }
 };
 const applybundlerInfoDefaults = (rspackFuture, library) => {
     if (typeof rspackFuture === "object") {
@@ -597,7 +600,7 @@ const applyOutputDefaults = (output, { context, outputModule, targetProperties:
     const optimistic = (v) => v || v === undefined;
     const conditionallyOptimistic = (v, c) => (v === undefined && c) || v;
     F(environment, "globalThis", () => tp?.globalThis);
-    F(environment, "bigIntLiteral", () => tp?.bigIntLiteral);
+    F(environment, "bigIntLiteral", () => tp && optimistic(tp.bigIntLiteral));
     F(environment, "const", () => tp && optimistic(tp.const));
     F(environment, "arrowFunction", () => tp && optimistic(tp.arrowFunction));
     F(environment, "asyncFunction", () => tp && optimistic(tp.asyncFunction));

package/dist/config/zod.d.ts

@@ -13,7 +13,7 @@ declare const name: z.ZodString;
 export type Name = z.infer<typeof name>;
 declare const dependencies: z.ZodArray<z.ZodString, "many">;
 export type Dependencies = z.infer<typeof dependencies>;
-declare const context: z.ZodString;
+declare const context: z.ZodEffects<z.ZodString, string, string>;
 export type Context = z.infer<typeof context>;
 declare const mode: z.ZodEnum<["development", "production", "none"]>;
 export type Mode = z.infer<typeof mode>;
@@ -5967,18 +5967,21 @@ declare const rspackFutureOptions: z.ZodObject<{
         version?: string | undefined;
         bundler?: string | undefined;
     }>>;
+    newIncremental: z.ZodOptional<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
     bundlerInfo?: {
         force?: boolean | ("version" | "uniqueId")[] | undefined;
         version?: string | undefined;
         bundler?: string | undefined;
     } | undefined;
+    newIncremental?: boolean | undefined;
 }, {
     bundlerInfo?: {
         force?: boolean | ("version" | "uniqueId")[] | undefined;
         version?: string | undefined;
         bundler?: string | undefined;
     } | undefined;
+    newIncremental?: boolean | undefined;
 }>;
 export type RspackFutureOptions = z.infer<typeof rspackFutureOptions>;
 declare const lazyCompilationOptions: z.ZodObject<{
@@ -6201,18 +6204,21 @@ declare const experiments: z.ZodObject<{
             version?: string | undefined;
             bundler?: string | undefined;
         }>>;
+        newIncremental: z.ZodOptional<z.ZodBoolean>;
     }, "strict", z.ZodTypeAny, {
         bundlerInfo?: {
             force?: boolean | ("version" | "uniqueId")[] | undefined;
             version?: string | undefined;
             bundler?: string | undefined;
         } | undefined;
+        newIncremental?: boolean | undefined;
     }, {
         bundlerInfo?: {
             force?: boolean | ("version" | "uniqueId")[] | undefined;
             version?: string | undefined;
             bundler?: string | undefined;
         } | undefined;
+        newIncremental?: boolean | undefined;
     }>>;
 }, "strict", z.ZodTypeAny, {
     css?: boolean | undefined;
@@ -6246,6 +6252,7 @@ declare const experiments: z.ZodObject<{
             version?: string | undefined;
             bundler?: string | undefined;
         } | undefined;
+        newIncremental?: boolean | undefined;
     } | undefined;
 }, {
     css?: boolean | undefined;
@@ -6279,6 +6286,7 @@ declare const experiments: z.ZodObject<{
             version?: string | undefined;
             bundler?: string | undefined;
         } | undefined;
+        newIncremental?: boolean | undefined;
     } | undefined;
 }>;
 export type Experiments = z.infer<typeof experiments>;
@@ -7245,18 +7253,21 @@ export declare const rspackOptions: z.ZodObject<{
                 version?: string | undefined;
                 bundler?: string | undefined;
             }>>;
+            newIncremental: z.ZodOptional<z.ZodBoolean>;
         }, "strict", z.ZodTypeAny, {
             bundlerInfo?: {
                 force?: boolean | ("version" | "uniqueId")[] | undefined;
                 version?: string | undefined;
                 bundler?: string | undefined;
             } | undefined;
+            newIncremental?: boolean | undefined;
         }, {
             bundlerInfo?: {
                 force?: boolean | ("version" | "uniqueId")[] | undefined;
                 version?: string | undefined;
                 bundler?: string | undefined;
             } | undefined;
+            newIncremental?: boolean | undefined;
         }>>;
     }, "strict", z.ZodTypeAny, {
         css?: boolean | undefined;
@@ -7290,6 +7301,7 @@ export declare const rspackOptions: z.ZodObject<{
                 version?: string | undefined;
                 bundler?: string | undefined;
             } | undefined;
+            newIncremental?: boolean | undefined;
         } | undefined;
     }, {
         css?: boolean | undefined;
@@ -7323,6 +7335,7 @@ export declare const rspackOptions: z.ZodObject<{
                 version?: string | undefined;
                 bundler?: string | undefined;
             } | undefined;
+            newIncremental?: boolean | undefined;
         } | undefined;
     }>>;
     externals: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodType<RegExp, z.ZodTypeDef, RegExp>]>, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodArray<z.ZodString, "many">]>, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>]>>]>, z.ZodFunction<z.ZodTuple<[z.ZodObject<{
@@ -7478,7 +7491,7 @@ export declare const rspackOptions: z.ZodObject<{
         stream?: NodeJS.WritableStream | undefined;
     }>>;
     cache: z.ZodOptional<z.ZodBoolean>;
-    context: z.ZodOptional<z.ZodString>;
+    context: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
     devtool: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<false>, z.ZodEnum<["eval", "cheap-source-map", "cheap-module-source-map", "source-map", "inline-cheap-source-map", "inline-cheap-module-source-map", "inline-source-map", "inline-nosources-cheap-source-map", "inline-nosources-cheap-module-source-map", "inline-nosources-source-map", "nosources-cheap-source-map", "nosources-cheap-module-source-map", "nosources-source-map", "hidden-nosources-cheap-source-map", "hidden-nosources-cheap-module-source-map", "hidden-nosources-source-map", "hidden-cheap-source-map", "hidden-cheap-module-source-map", "hidden-source-map", "eval-cheap-source-map", "eval-cheap-module-source-map", "eval-source-map", "eval-nosources-cheap-source-map", "eval-nosources-cheap-module-source-map", "eval-nosources-source-map"]>]>>;
     node: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<false>, z.ZodObject<{
         __dirname: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["warn-mock", "mock", "eval-only", "node-module"]>]>>;
@@ -9354,6 +9367,7 @@ export declare const rspackOptions: z.ZodObject<{
                 version?: string | undefined;
                 bundler?: string | undefined;
             } | undefined;
+            newIncremental?: boolean | undefined;
         } | undefined;
     } | undefined;
     externals?: string | RegExp | Record<string, string | boolean | string[] | Record<string, string | string[]>> | ((args_0: {
@@ -9927,6 +9941,7 @@ export declare const rspackOptions: z.ZodObject<{
                 version?: string | undefined;
                 bundler?: string | undefined;
             } | undefined;
+            newIncremental?: boolean | undefined;
         } | undefined;
     } | undefined;
     externals?: string | RegExp | Record<string, string | boolean | string[] | Record<string, string | string[]>> | ((args_0: {

package/dist/config/zod.js

@@ -1,6 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rspackOptions = exports.externalsType = void 0;
+const node_path_1 = __importDefault(require("node:path"));
 const zod_1 = require("../../compiled/zod");
 const Chunk_1 = require("../Chunk");
 const Module_1 = require("../Module");
@@ -16,7 +20,9 @@ const name = zod_1.z.string();
 const dependencies = zod_1.z.array(name);
 //#endregion
 //#region Context
-const context = zod_1.z.string();
+const context = zod_1.z.string().refine(val => node_path_1.default.isAbsolute(val), val => ({
+    message: `The provided value ${JSON.stringify(val)} must be an absolute path.`
+}));
 //#endregion
 //#region Mode
 const mode = zod_1.z.enum(["development", "production", "none"]);
@@ -861,7 +867,8 @@ const rspackFutureOptions = zod_1.z.strictObject({
             .or(zod_1.z.array(zod_1.z.enum(["version", "uniqueId"])))
             .optional()
     })
-        .optional()
+        .optional(),
+    newIncremental: zod_1.z.boolean().optional()
 });
 const listenOptions = zod_1.z.object({
     port: zod_1.z.number().optional(),

package/dist/exports.d.ts

@@ -33,6 +33,8 @@ type Config = {
 };
 export declare const config: Config;
 export type * from "./config";
+import { ValidationError } from "./util/validate";
+export { ValidationError };
 export declare const util: {
     createHash: (algorithm: (string & {}) | "debug" | "xxhash64" | "md4" | "native-md4" | (new () => import("./util/hash").default)) => import("./util/hash").default;
     cleverMerge: <First, Second>(first: First, second: Second) => First | Second | (First & Second);

package/dist/exports.js

@@ -26,8 +26,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CssExtractRspackPlugin = exports.EvalDevToolModulePlugin = exports.EvalSourceMapDevToolPlugin = exports.SourceMapDevToolPlugin = exports.CopyRspackPlugin = exports.LightningCssMinimizerRspackPlugin = exports.SwcJsMinimizerRspackPlugin = exports.HtmlRspackPlugin = exports.sharing = exports.container = exports.optimize = exports.webworker = exports.javascript = exports.wasm = exports.library = exports.electron = exports.node = exports.web = exports.NormalModuleReplacementPlugin = exports.LoaderTargetPlugin = exports.LoaderOptionsPlugin = exports.EnvironmentPlugin = exports.NoEmitOnErrorsPlugin = exports.HotModuleReplacementPlugin = exports.ExternalsPlugin = exports.DynamicEntryPlugin = exports.EntryPlugin = exports.ProgressPlugin = exports.DefinePlugin = exports.ProvidePlugin = exports.IgnorePlugin = exports.BannerPlugin = exports.EntryOptionPlugin = exports.util = exports.config = exports.sources = exports.WebpackError = exports.Template = exports.ModuleFilenameHelpers = exports.Stats = exports.RuntimeGlobals = exports.NormalModule = exports.MultiStats = exports.WebpackOptionsApply = exports.RspackOptionsApply = exports.MultiCompiler = exports.Compiler = exports.Compilation = exports.version = exports.rspackVersion = void 0;
-exports.experiments = void 0;
+exports.EvalDevToolModulePlugin = exports.EvalSourceMapDevToolPlugin = exports.SourceMapDevToolPlugin = exports.CopyRspackPlugin = exports.LightningCssMinimizerRspackPlugin = exports.SwcJsMinimizerRspackPlugin = exports.HtmlRspackPlugin = exports.sharing = exports.container = exports.optimize = exports.webworker = exports.javascript = exports.wasm = exports.library = exports.electron = exports.node = exports.web = exports.NormalModuleReplacementPlugin = exports.LoaderTargetPlugin = exports.LoaderOptionsPlugin = exports.EnvironmentPlugin = exports.NoEmitOnErrorsPlugin = exports.HotModuleReplacementPlugin = exports.ExternalsPlugin = exports.DynamicEntryPlugin = exports.EntryPlugin = exports.ProgressPlugin = exports.DefinePlugin = exports.ProvidePlugin = exports.IgnorePlugin = exports.BannerPlugin = exports.EntryOptionPlugin = exports.util = exports.ValidationError = exports.config = exports.sources = exports.WebpackError = exports.Template = exports.ModuleFilenameHelpers = exports.Stats = exports.RuntimeGlobals = exports.NormalModule = exports.MultiStats = exports.WebpackOptionsApply = exports.RspackOptionsApply = exports.MultiCompiler = exports.Compiler = exports.Compilation = exports.version = exports.rspackVersion = void 0;
+exports.experiments = exports.CssExtractRspackPlugin = void 0;
 const package_json_1 = require("../package.json");
 // this is a hack to be compatible with plugin which detect webpack's version
 const rspackVersion = package_json_1.version;
@@ -67,6 +67,8 @@ exports.config = {
     getNormalizedWebpackOptions: config_1.getNormalizedRspackOptions,
     applyWebpackOptionsDefaults: config_1.applyRspackOptionsDefaults
 };
+const validate_1 = require("./util/validate");
+Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function () { return validate_1.ValidationError; } });
 const cleverMerge_1 = require("./util/cleverMerge");
 const createHash_1 = require("./util/createHash");
 exports.util = { createHash: createHash_1.createHash, cleverMerge: cleverMerge_1.cachedCleverMerge };

package/dist/loader-runner/index.js

@@ -82,7 +82,9 @@ function createLoaderObject(loader, compiler) {
                 }
                 obj.ident = ident;
             }
-            obj.type = value.type;
+            // CHANGE: `rspack_core` returns empty string for `undefined` type.
+            // Comply to webpack test case: tests/webpack-test/cases/loaders/cjs-loader-type/index.js
+            obj.type = value.type === "" ? undefined : value.type;
             if (obj.options === null)
                 obj.query = "";
             else if (obj.options === undefined)

package/dist/util/validate.d.ts

@@ -1,3 +1,6 @@
 import type { z } from "../../compiled/zod";
+export declare class ValidationError extends Error {
+    constructor(message: string);
+}
 export declare function validate<T extends z.ZodType>(opts: any, schema: T): void;
 export declare function isValidate<T extends z.ZodType>(opts: any, schema: T): boolean;

package/dist/util/validate.js

@@ -1,34 +1,70 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isValidate = exports.validate = void 0;
+exports.isValidate = exports.validate = exports.ValidationError = void 0;
 const zod_validation_error_1 = require("../../compiled/zod-validation-error");
+class ValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ValidationError";
+    }
+}
+exports.ValidationError = ValidationError;
 function validate(opts, schema) {
     const res = schema.safeParse(opts);
     if (!res.success) {
         const strategy = process.env.RSPACK_CONFIG_VALIDATE ?? "strict";
         if (strategy === "loose-silent")
             return;
-        const issueSeparator = "$issue$";
-        const prefixSeparator = "$prefix$";
-        const validationErr = (0, zod_validation_error_1.fromZodError)(res.error, {
-            prefix: "Configuration error",
-            prefixSeparator,
-            issueSeparator
-        });
-        // The output validationErr.message looks like
-        // `Configuration error$prefix$xxxx error$issue$yyy error$issue$zzz error`
-        const [prefix, reason] = validationErr.message.split(prefixSeparator);
-        const reasonItem = reason.split(issueSeparator);
-        const friendlyErr = new Error(`${prefix}:\n${reasonItem.map(item => `- ${item}`).join("\n")}`);
-        if (strategy === "loose") {
-            console.error(friendlyErr.message);
+        let friendlyErr;
+        const originalIssues = res.error.issues;
+        // Issues with code `unrecognized_keys` are ignored. Other issues are thrown.
+        // This does not work when `zodError.issues` is empty so we need to check the length of `zodError.issues`.
+        // See: https://github.com/causaly/zod-validation-error/blob/62684ba47cba9cbd84e2a75dfd5fd06dcd0e1ad5/lib/fromZodError.ts#L53
+        if (strategy === "loose-unrecognized-keys" && res.error.issues.length > 0) {
+            // This is based on the invariant that `fromZodError` always reads `zodError.errors` first and
+            // `zodError.errors` always returns `zodError.issues`:
+            // See: https://github.com/causaly/zod-validation-error/blob/62684ba47cba9cbd84e2a75dfd5fd06dcd0e1ad5/lib/fromZodError.ts#L55
+            // Also see: https://github.com/colinhacks/zod/blob/8552233c77426f77d3586cc877f7aec1aa0aa45b/src/ZodError.ts#L200
+            const unrecognizedKeys = originalIssues.filter(issue => issue.code === "unrecognized_keys");
+            if (unrecognizedKeys.length > 0) {
+                res.error.issues = unrecognizedKeys;
+                friendlyErr = toValidationError(res.error);
+                console.error(friendlyErr.message);
+                res.error.issues = originalIssues;
+            }
+            res.error.issues = originalIssues.filter(issue => issue.code !== "unrecognized_keys");
+            if (res.error.issues.length > 0) {
+                throw toValidationError(res.error);
+            }
+            return;
         }
-        else {
-            throw friendlyErr;
+        if (strategy === "loose-unrecognized-keys" || strategy === "loose") {
+            friendlyErr = toValidationError(res.error);
+            console.error(friendlyErr.message);
+            return;
         }
+        // strict
+        friendlyErr = toValidationError(res.error);
+        throw friendlyErr;
     }
 }
 exports.validate = validate;
+function toValidationError(error) {
+    const issueSeparator = "$issue$";
+    const prefixSeparator = "$prefix$";
+    const validationErr = (0, zod_validation_error_1.fromZodError)(error, {
+        prefix: "Invalid configuration object. Rspack has been initialized using a configuration object that does not match the API schema.",
+        prefixSeparator,
+        issueSeparator
+    });
+    // The output validationErr.message looks like
+    // `Configuration error$prefix$xxxx error$issue$yyy error$issue$zzz error`
+    const [prefix, reason] = validationErr.message.split(prefixSeparator);
+    const reasonItem = reason.split(issueSeparator);
+    const message = `${prefix}\n${reasonItem.map(item => `- ${item}`).join("\n")}`;
+    const friendlyErr = new ValidationError(message);
+    return friendlyErr;
+}
 function isValidate(opts, schema) {
     try {
         validate(opts, schema);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack/core",
-  "version": "1.0.0-rc.0",
+  "version": "1.0.0-rc.2",
   "webpackVersion": "5.75.0",
   "license": "MIT",
   "description": "The fast Rust-based web bundler with webpack-compatible API",
@@ -54,13 +54,13 @@
     "webpack-sources": "3.2.3",
     "webpack-dev-server": "^5.0.4",
     "zod": "^3.23.8",
-    "zod-validation-error": "1.3.1"
+    "zod-validation-error": "3.3.1"
   },
   "dependencies": {
     "@module-federation/runtime-tools": "0.5.1",
     "@rspack/lite-tapable": "1.0.0",
     "caniuse-lite": "^1.0.30001616",
-    "@rspack/binding": "1.0.0-rc.0"
+    "@rspack/binding": "1.0.0-rc.2"
   },
   "peerDependencies": {
     "@swc/helpers": ">=0.5.1"