@lynx-js/react-refresh-webpack-plugin-canary 0.3.1

package/CHANGELOG.md

@@ -0,0 +1,18 @@
+# @lynx-js/react-refresh-webpack-plugin
+
+## 0.3.1
+
+### Patch Changes
+
+- a30c83d: Support `@lynx-js/react-webpack-plugin@0.6.0`
+- 5f8d492: Support `@lynx-js/react-webpack-plugin@0.6.0`
+
+## 0.3.0
+
+### Minor Changes
+
+- 587a782: **BRAKING CHANGE**: Require `@lynx-js/react` v0.100.0
+
+### Patch Changes
+
+- 1938bb1: Make peerDependencies of `@lynx-js/react` optional.

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,3 @@
+<h2 align="center">@lynx-js/react-refresh-webpack-plugin</h2>
+
+A webpack plugin to hot refresh for Lynx

package/lib/ReactRefreshRspackPlugin.d.ts

@@ -0,0 +1,81 @@
+import type { Compiler } from '@rspack/core';
+/**
+ * The options for {@link ReactRefreshRspackPlugin}.
+ *
+ * @public
+ */
+export interface ReactRefreshRspackPluginOptions {
+}
+/**
+ * ReactRefreshRspackPlugin allows using fast refresh in ReactLynx.
+ *
+ * @example
+ * ```js
+ * // rspack.config.js
+ * import { ReactRefreshRspackPlugin } from '@lynx-js/react-refresh-webpack-plugin'
+ * export default {
+ *   module: {
+ *     rules: [
+ *       {
+ *         test: /\.[jt]sx?$/,
+ *         exclude: [
+ *           /node_modules/,
+ *           /@lynx-js/,
+ *           /react-refresh/,
+ *           /compiler-nodiff-runtime3/,
+ *           ReactRefreshRspackPlugin.loader,
+ *         ],
+ *         use: [ReactRefreshRspackPlugin.loader],
+ *       },
+ *     ],
+ *   },
+ *   plugins: [new ReactRefreshRspackPlugin()],
+ * }
+ * ```
+ *
+ * @public
+ */
+export declare class ReactRefreshRspackPlugin {
+    #private;
+    /**
+     * @param options - The options for react refresh.
+     */
+    constructor(options?: ReactRefreshRspackPluginOptions);
+    /**
+     * The loader for react refresh.
+     *
+     * @remarks
+     * Please note that the runtime of react should be ignored. See the example below:
+     *
+     * @example
+     * ```js
+     * // rspack.config.js
+     * import { ReactRefreshRspackPlugin } from '@lynx-js/react-refresh-webpack-plugin'
+     * import { ReactWebpackPlugin } from '@lynx-js/react-webpack-plugin'
+     *
+     * export default {
+     *   module: {
+     *     rules: [
+     *       {
+     *         issueLayer: ReactWebpackPlugin.LAYERS.BACKGROUND,
+     *         test: /\.[jt]sx?$/,
+     *         exclude: [
+     *           /node_modules/,
+     *           /@lynx-js\/react/,
+     *           ReactRefreshRspackPlugin.loader,
+     *         ],
+     *         use: [ReactRefreshRspackPlugin.loader],
+     *       },
+     *     ],
+     *   },
+     *   plugins: [new ReactRefreshRspackPlugin()],
+     * }
+     * ```
+     */
+    static loader: string;
+    /**
+     * The entry point of a rspack plugin.
+     * @param compiler - the rspack compiler
+     */
+    apply(compiler: Compiler): void;
+}

package/lib/ReactRefreshRspackPlugin.js

@@ -0,0 +1,127 @@
+// Copyright 2024 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { LAYERS } from '@lynx-js/react-webpack-plugin';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const require = createRequire(__filename);
+const PLUGIN_NAME = 'ReactRefreshRspackPlugin';
+/**
+ * ReactRefreshRspackPlugin allows using fast refresh in ReactLynx.
+ *
+ * @example
+ * ```js
+ * // rspack.config.js
+ * import { ReactRefreshRspackPlugin } from '@lynx-js/react-refresh-webpack-plugin'
+ * export default {
+ *   module: {
+ *     rules: [
+ *       {
+ *         test: /\.[jt]sx?$/,
+ *         exclude: [
+ *           /node_modules/,
+ *           /@lynx-js/,
+ *           /react-refresh/,
+ *           /compiler-nodiff-runtime3/,
+ *           ReactRefreshRspackPlugin.loader,
+ *         ],
+ *         use: [ReactRefreshRspackPlugin.loader],
+ *       },
+ *     ],
+ *   },
+ *   plugins: [new ReactRefreshRspackPlugin()],
+ * }
+ * ```
+ *
+ * @public
+ */
+export class ReactRefreshRspackPlugin {
+    /**
+     * @param options - The options for react refresh.
+     */
+    constructor(options = {}) {
+        this.#options = options;
+    }
+    #options;
+    /**
+     * The loader for react refresh.
+     *
+     * @remarks
+     * Please note that the runtime of react should be ignored. See the example below:
+     *
+     * @example
+     * ```js
+     * // rspack.config.js
+     * import { ReactRefreshRspackPlugin } from '@lynx-js/react-refresh-webpack-plugin'
+     * import { ReactWebpackPlugin } from '@lynx-js/react-webpack-plugin'
+     *
+     * export default {
+     *   module: {
+     *     rules: [
+     *       {
+     *         issueLayer: ReactWebpackPlugin.LAYERS.BACKGROUND,
+     *         test: /\.[jt]sx?$/,
+     *         exclude: [
+     *           /node_modules/,
+     *           /@lynx-js\/react/,
+     *           ReactRefreshRspackPlugin.loader,
+     *         ],
+     *         use: [ReactRefreshRspackPlugin.loader],
+     *       },
+     *     ],
+     *   },
+     *   plugins: [new ReactRefreshRspackPlugin()],
+     * }
+     * ```
+     */
+    static loader = require.resolve('../loader.cjs');
+    /**
+     * The entry point of a rspack plugin.
+     * @param compiler - the rspack compiler
+     */
+    apply(compiler) {
+        if (process.env['NODE_ENV'] === 'production'
+            || compiler.options.mode === 'production') {
+            return;
+        }
+        const { ProvidePlugin } = compiler.webpack;
+        const provide = {
+            __prefresh_utils__: path.resolve(__dirname, '../runtime/refresh.cjs'),
+        };
+        if (this.#options.overlay) {
+            provide['__prefresh_errors__'] = this.#options.overlay.module;
+        }
+        new ProvidePlugin(provide).apply(compiler);
+        compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
+            compilation.hooks.runtimeModule.tap(PLUGIN_NAME, (runtimeModule) => {
+                if (runtimeModule.name === 'hot_module_replacement') {
+                    this.#appendInterceptRuntimeModule(runtimeModule);
+                }
+            });
+        });
+    }
+    #appendInterceptRuntimeModule(runtimeModule) {
+        runtimeModule.source.source = Buffer.concat([
+            Buffer.from(runtimeModule.source.source),
+            Buffer.from(fs.readFileSync(path.resolve(__dirname, '../runtime/intercept.cjs'), 'utf-8')
+                .replaceAll('$MAIN_THREAD_LAYER$', LAYERS.MAIN_THREAD)
+                .replaceAll('$BACKGROUND_LAYER$', LAYERS.BACKGROUND)),
+            // TODO: merge this with the webpack plugin
+            Buffer.from(`
+// noop fns to prevent runtime errors during initialization
+if (typeof globalThis !== "undefined") {
+  globalThis.$RefreshReg$ = function () {};
+  globalThis.$RefreshSig$ = function () {
+    return function(type) {
+      return type;
+    };
+  };
+}`),
+        ]);
+    }
+}
+//# sourceMappingURL=ReactRefreshRspackPlugin.js.map

package/lib/ReactRefreshWebpackPlugin.d.ts

@@ -0,0 +1,66 @@
+import type { Compiler } from 'webpack';
+/**
+ * The options for {@link ReactRefreshWebpackPlugin}.
+ *
+ * @public
+ */
+export interface ReactRefreshWebpackPluginOptions {
+}
+/**
+ * ReactRefreshWebpackPlugin allows using fast refresh in ReactLynx.
+ *
+ * @example
+ * ```js
+ * // webpack.config.js
+ * import { ReactRefreshWebpackPlugin } from '@lynx-js/react-refresh-webpack-plugin'
+ * export default {
+ *   plugins: [new ReactRefreshWebpackPlugin()],
+ * }
+ * ```
+ *
+ * @public
+ */
+export declare class ReactRefreshWebpackPlugin {
+    #private;
+    /**
+     * @param options - The options for react refresh.
+     */
+    constructor(options?: ReactRefreshWebpackPluginOptions | undefined);
+    /**
+     * The loader for react refresh.
+     *
+     * @remarks
+     * Please note that the runtime of react should be ignored. See the example below:
+     *
+     * @example
+     * ```js
+     * // webpack.config.js
+     * import { ReactRefreshWebpackPlugin } from '@lynx-js/react-refresh-webpack-plugin'
+     * import { ReactWebpackPlugin } from '@lynx-js/react-webpack-plugin'
+     *
+     * export default {
+     *   module: {
+     *     rules: [
+     *       {
+     *         issueLayer: ReactWebpackPlugin.LAYERS.BACKGROUND,
+     *         test: /\.[jt]sx?$/,
+     *         exclude: [
+     *           /node_modules/,
+     *           /@lynx-js\/react/,
+     *           ReactRefreshWebpackPlugin.loader,
+     *         ],
+     *         use: [ReactRefreshWebpackPlugin.loader],
+     *       },
+     *     ],
+     *   },
+     *   plugins: [new ReactRefreshWebpackPlugin()],
+     * }
+     * ```
+     */
+    static loader: string;
+    /**
+     * The entry point of a webpack plugin.
+     * @param compiler - the webpack compiler
+     */
+    apply(compiler: Compiler): void;
+}

package/lib/ReactRefreshWebpackPlugin.js

@@ -0,0 +1,122 @@
+// Copyright 2024 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { LAYERS } from '@lynx-js/react-webpack-plugin';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+const PLUGIN_NAME = 'ReactRefreshWebpackPlugin';
+/**
+ * ReactRefreshWebpackPlugin allows using fast refresh in ReactLynx.
+ *
+ * @example
+ * ```js
+ * // webpack.config.js
+ * import { ReactRefreshWebpackPlugin } from '@lynx-js/react-refresh-webpack-plugin'
+ * export default {
+ *   plugins: [new ReactRefreshWebpackPlugin()],
+ * }
+ * ```
+ *
+ * @public
+ */
+export class ReactRefreshWebpackPlugin {
+    /**
+     * @param options - The options for react refresh.
+     */
+    constructor(options = {}) {
+        this.#options = options;
+    }
+    #options;
+    /**
+     * The loader for react refresh.
+     *
+     * @remarks
+     * Please note that the runtime of react should be ignored. See the example below:
+     *
+     * @example
+     * ```js
+     * // webpack.config.js
+     * import { ReactRefreshWebpackPlugin } from '@lynx-js/react-refresh-webpack-plugin'
+     * import { ReactWebpackPlugin } from '@lynx-js/react-webpack-plugin'
+     *
+     * export default {
+     *   module: {
+     *     rules: [
+     *       {
+     *         issueLayer: ReactWebpackPlugin.LAYERS.BACKGROUND,
+     *         test: /\.[jt]sx?$/,
+     *         exclude: [
+     *           /node_modules/,
+     *           /@lynx-js\/react/,
+     *           ReactRefreshWebpackPlugin.loader,
+     *         ],
+     *         use: [ReactRefreshWebpackPlugin.loader],
+     *       },
+     *     ],
+     *   },
+     *   plugins: [new ReactRefreshWebpackPlugin()],
+     * }
+     * ```
+     */
+    static loader = require.resolve('../loader.cjs');
+    /**
+     * The entry point of a webpack plugin.
+     * @param compiler - the webpack compiler
+     */
+    apply(compiler) {
+        if (process.env['NODE_ENV'] === 'production'
+            || compiler.options.mode === 'production') {
+            return;
+        }
+        const { EntryPlugin, ProvidePlugin, RuntimeGlobals, RuntimeModule, } = compiler.webpack;
+        const provide = {
+            __prefresh_utils__: path.resolve(__dirname, '../runtime/refresh.cjs'),
+        };
+        if (this.#options.overlay) {
+            provide['__prefresh_errors__'] = this.#options.overlay.module;
+        }
+        new ProvidePlugin(provide).apply(compiler);
+        new EntryPlugin(compiler.context, '@lynx-js/react-refresh', 
+        // @ts-expect-error: `undefined` means use globalEntry
+        { name: undefined }).apply(compiler);
+        compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+            if (compilation.compiler !== compiler) {
+                // Not pass to child compiler
+                return;
+            }
+            class RefreshRuntimeModule extends RuntimeModule {
+                constructor() {
+                    super('refresh', RuntimeModule.STAGE_BASIC);
+                }
+                generate() {
+                    return fs.readFileSync(path.resolve(__dirname, '../runtime/intercept.cjs'), 'utf-8')
+                        .replaceAll('$MAIN_THREAD_LAYER$', LAYERS.MAIN_THREAD)
+                        .replaceAll('$BACKGROUND_LAYER$', LAYERS.BACKGROUND);
+                }
+            }
+            compilation.mainTemplate.hooks.localVars.tap(PLUGIN_NAME, source => {
+                return `
+            ${source}
+            // noop fns to prevent runtime errors during initialization
+            if (typeof globalThis !== "undefined") {
+              globalThis.$RefreshReg$ = function () {};
+              globalThis.$RefreshSig$ = function () {
+                return function(type) {
+                  return type;
+                };
+              };
+            }
+          `;
+            });
+            compilation.hooks.additionalTreeRuntimeRequirements.tap(PLUGIN_NAME, (chunk, runtimeRequirements) => {
+                runtimeRequirements.add(RuntimeGlobals.interceptModuleExecution);
+                compilation.addRuntimeModule(chunk, new RefreshRuntimeModule());
+            });
+        });
+    }
+}
+//# sourceMappingURL=ReactRefreshWebpackPlugin.js.map

package/lib/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @packageDocumentation
+ *
+ * A webpack plugin to integrate {@link https://github.com/preactjs/prefresh | prefresh} with ReactLynx.
+ *
+ * @remarks
+ * Please use {@link ReactRefreshWebpackPlugin} for `'webpack'`.
+ *
+ * And use {@link ReactRefreshRspackPlugin} for `'rspack'`.
+ */
+export { ReactRefreshWebpackPlugin } from './ReactRefreshWebpackPlugin.js';
+export type { ReactRefreshWebpackPluginOptions } from './ReactRefreshWebpackPlugin.js';
+export { ReactRefreshRspackPlugin } from './ReactRefreshRspackPlugin.js';
+export type { ReactRefreshRspackPluginOptions } from './ReactRefreshRspackPlugin.js';

package/lib/index.js

@@ -0,0 +1,16 @@
+// Copyright 2024 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+/**
+ * @packageDocumentation
+ *
+ * A webpack plugin to integrate {@link https://github.com/preactjs/prefresh | prefresh} with ReactLynx.
+ *
+ * @remarks
+ * Please use {@link ReactRefreshWebpackPlugin} for `'webpack'`.
+ *
+ * And use {@link ReactRefreshRspackPlugin} for `'rspack'`.
+ */
+export { ReactRefreshWebpackPlugin } from './ReactRefreshWebpackPlugin.js';
+export { ReactRefreshRspackPlugin } from './ReactRefreshRspackPlugin.js';
+//# sourceMappingURL=index.js.map

package/loader.cjs

@@ -0,0 +1,16 @@
+// Copyright 2024 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+const fs = require('node:fs');
+const path = require('node:path');
+
+const LOADER_RUNTIME = fs.readFileSync(
+  path.resolve(__dirname, './runtime/loader.cjs'),
+  'utf-8',
+);
+
+const RefreshHotLoader = function RefreshHotLoader(source, inputSourceMap) {
+  this.callback(null, source + '\n\n' + LOADER_RUNTIME, inputSourceMap);
+};
+
+module.exports = RefreshHotLoader;

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@lynx-js/react-refresh-webpack-plugin-canary",
+  "version": "0.3.1",
+  "description": "A webpack plugin to hot refresh for Lynx.",
+  "keywords": [
+    "webpack",
+    "Lynx"
+  ],
+  "license": "Apache-2.0",
+  "author": {
+    "name": "Qingyu Wang",
+    "email": "colinwang.0616@gmail.com"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "types": "./lib/index.d.ts",
+  "files": [
+    "lib",
+    "!lib/**/*.js.map",
+    "runtime",
+    "loader.cjs",
+    "CHANGELOG.md",
+    "README.md"
+  ],
+  "devDependencies": {
+    "@microsoft/api-extractor": "7.51.0",
+    "@rspack/core": "1.2.6",
+    "swc-loader": "^0.2.6",
+    "webpack": "^5.98.0",
+    "@lynx-js/react-refresh": "0.1.0",
+    "@lynx-js/react": "npm:@lynx-js/react-canary@0.105.0-canary-20250302-1abf8f01",
+    "@lynx-js/react-webpack-plugin": "npm:@lynx-js/react-webpack-plugin-canary@0.6.6-canary-20250302-1abf8f01",
+    "@lynx-js/test-tools": "0.0.0"
+  },
+  "peerDependencies": {
+    "@lynx-js/react-webpack-plugin": "*"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "api-extractor": "api-extractor run --verbose",
+    "test": "pnpm -w run test --project webpack/react-refresh"
+  }
+}

package/runtime/intercept.cjs

@@ -0,0 +1,74 @@
+// @ts-nocheck
+__webpack_require__.i.push(function(options) {
+  if (
+    // This means this is in main-thread
+    !globalThis.__PREFRESH__
+    // Loading a module of background layer in main-thread, we replace the layer with the main-thread.
+    && options.id.includes('($BACKGROUND_LAYER$)')
+  ) {
+    // We may serialize the snapshot from background to main-thread.
+    // The `(react:background)` layer in the module id cannot be found in the main-thread.
+    // Thus we replace it here to make HMR work.
+    //
+    // Maybe it is better to run chunk loading on main thread.
+    options.id = options.id.replace(
+      `($BACKGROUND_LAYER$)`, // This is replaced by ReactRefreshWebpackPlugin
+      '($MAIN_THREAD_LAYER$)', // This is replaced by ReactRefreshWebpackPlugin
+    );
+    const factory = __webpack_modules__[options.id];
+    if (factory) {
+      options.factory = factory;
+    }
+    return;
+  }
+  var originalFactory = options.factory;
+  options.factory = function(moduleObject, moduleExports, webpackRequire) {
+    var prevRefreshReg = globalThis.$RefreshReg$;
+    var prevRefreshSig = globalThis.$RefreshSig$;
+    globalThis.$RefreshSig$ = function() {
+      var status = 'begin';
+      var savedType;
+
+      return function(type, key, forceReset, getCustomHooks) {
+        // `globalThis.__PREFRESH__` may not exist when requiring `react`:
+        //   - require('react-refresh')
+        //     - require('react').options
+        //       - require('useSyncExternalStore')
+        //         - __REFRESH__.sign // not a function
+        // TODO(wangqingyu): Replace globalThis.__PREFRESH__ with lynx.__PREFRESH__
+        if (!globalThis.__PREFRESH__) {
+          return type;
+        }
+        if (!savedType) savedType = type;
+
+        status = globalThis.__PREFRESH__.sign(
+          type || savedType,
+          key,
+          forceReset,
+          getCustomHooks,
+          status,
+        );
+        return type;
+      };
+    };
+    var reg = function(currentModuleId) {
+      globalThis.$RefreshReg$ = function(type, id) {
+        // `globalThis.__PREFRESH__` may not exist when requiring `react`:
+        //   - require('react-refresh')
+        //     - require('react').options
+        //       - require('useSyncExternalStore')
+        //         - __REFRESH__.sign // not a function
+        if (globalThis.__PREFRESH__) {
+          globalThis.__PREFRESH__.register(type, currentModuleId + ' ' + id);
+        }
+      };
+    };
+    reg();
+    try {
+      originalFactory.call(this, moduleObject, moduleExports, webpackRequire);
+    } finally {
+      globalThis.$RefreshReg$ = prevRefreshReg;
+      globalThis.$RefreshSig$ = prevRefreshSig;
+    }
+  };
+});

package/runtime/loader.cjs

@@ -0,0 +1,50 @@
+// @ts-nocheck
+const isPrefreshComponent = __prefresh_utils__.shouldBind(module);
+
+const moduleHot = module.hot;
+
+if (moduleHot) {
+  const currentExports = __prefresh_utils__.getExports(module);
+  const previousHotModuleExports = moduleHot.data
+    && moduleHot.data.moduleExports;
+
+  __prefresh_utils__.registerExports(currentExports, module.id);
+
+  if (isPrefreshComponent) {
+    if (previousHotModuleExports) {
+      try {
+        __prefresh_utils__.flush();
+        if (
+          typeof __prefresh_errors__ !== 'undefined'
+          && __prefresh_errors__
+          && __prefresh_errors__.clearRuntimeErrors
+        ) {
+          __prefresh_errors__.clearRuntimeErrors();
+        }
+      } catch (e) {
+        // Only available in newer webpack versions.
+        if (moduleHot.invalidate) {
+          moduleHot.invalidate();
+        } else {
+          globalThis.location.reload();
+        }
+      }
+    }
+
+    moduleHot.dispose(data => {
+      data.moduleExports = __prefresh_utils__.getExports(module);
+    });
+
+    moduleHot.accept(function errorRecovery() {
+      if (
+        typeof __prefresh_errors__ !== 'undefined'
+        && __prefresh_errors__
+        && __prefresh_errors__.handleRuntimeError
+      ) {
+        __prefresh_errors__.handleRuntimeError(error);
+      }
+
+      require.cache[module.id].hot.accept(errorRecovery);
+    });
+  }
+}

package/runtime/refresh.cjs

@@ -0,0 +1,60 @@
+const { isComponent, flush } = require('@lynx-js/react/refresh');
+
+// eslint-disable-next-line
+const getExports = m => m.exports || m.__proto__.exports;
+
+function isSafeExport(key) {
+  return (
+    key === '__esModule'
+    || key === '__N_SSG'
+    || key === '__N_SSP'
+    || key === 'config'
+  );
+}
+
+function registerExports(moduleExports, moduleId) {
+  globalThis['__PREFRESH__'].register(moduleExports, moduleId + ' %exports%');
+  if (moduleExports == null || typeof moduleExports !== 'object') return;
+
+  for (const key in moduleExports) {
+    if (isSafeExport(key)) continue;
+    const exportValue = moduleExports[key];
+    const typeID = moduleId + ' %exports% ' + key;
+    globalThis['__PREFRESH__'].register(exportValue, typeID);
+  }
+}
+
+const shouldBind = m => {
+  let isCitizen = false;
+  const moduleExports = getExports(m);
+
+  if (isComponent(moduleExports)) {
+    isCitizen = true;
+  }
+
+  if (
+    moduleExports === undefined
+    || moduleExports === null
+    || typeof moduleExports !== 'object'
+  ) {
+    isCitizen = isCitizen || false;
+  } else {
+    for (const key in moduleExports) {
+      if (key === '__esModule') continue;
+
+      const exportValue = moduleExports[key];
+      if (isComponent(exportValue)) {
+        isCitizen = isCitizen || true;
+      }
+    }
+  }
+
+  return isCitizen;
+};
+
+module.exports = Object.freeze({
+  getExports,
+  shouldBind,
+  flush,
+  registerExports,
+});