@prefresh/rolldown 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Preact Authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,41 @@
+# @prefresh/rolldown
+
+[![npm version](https://badgen.net/npm/v/@prefresh/rolldown)](https://www.npmjs.com/package/@prefresh/rolldown)
+
+## Setup
+
+```bash
+pnpm add -D @prefresh/rolldown rolldown
+```
+
+Then add it to your Rolldown config:
+
+```js
+import prefresh from '@prefresh/rolldown';
+
+export default {
+  plugins: [prefresh()],
+};
+```
+
+This plugin memoizes `createContext()` calls so context identity survives hot updates. It is intended to be used alongside Rolldown's React refresh transform for component refresh handling.
+
+## Options
+
+### `library`
+
+Libraries to detect `createContext` imports from.
+
+Default: `['preact', 'react', 'preact/compat']`
+
+```js
+prefresh({
+  library: ['preact', 'preact/compat'],
+});
+```
+
+### `enabled`
+
+Enable or disable the transform.
+
+Default: `true` in development and `false` otherwise.

package/index.d.ts

@@ -0,0 +1,11 @@
+import type { Plugin } from 'rolldown';
+
+export interface PrefreshRolldownOptions {
+  library?: string[];
+  enabled?: boolean;
+}
+
+declare function prefreshPlugin(options?: PrefreshRolldownOptions): Plugin;
+
+export default prefreshPlugin;
+export { prefreshPlugin as prefresh };

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@prefresh/rolldown",
+  "version": "0.0.0",
+  "description": "A rolldown plugin to preserve Preact context identity during HMR.",
+  "$schema": "https://raw.githubusercontent.com/vitejs/vite-plugin-registry/refs/heads/main/data/schema/extended-package-json.schema.json",
+  "type": "module",
+  "main": "./src/index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./src/index.js",
+      "default": "./src/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "index.d.ts"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/preactjs/prefresh.git",
+    "directory": "packages/rolldown"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/preactjs/prefresh/issues"
+  },
+  "homepage": "https://github.com/preactjs/prefresh/tree/main/packages/rolldown#readme",
+  "keywords": [
+    "hmr",
+    "preact",
+    "prefresh",
+    "rolldown",
+    "rolldown-plugin",
+    "vite-plugin"
+  ],
+  "dependencies": {
+    "oxc-unshadowed-visitor": "^0.0.1",
+    "rolldown-string": "^0.3.0"
+  },
+  "devDependencies": {
+    "rolldown": "^1.0.0-rc.12"
+  },
+  "peerDependencies": {
+    "rolldown": "^1.0.0-rc.12",
+    "vite": "^8.0.0"
+  },
+  "peerDependenciesMeta": {
+    "vite": {
+      "optional": true
+    }
+  },
+  "compatiblePackages": {
+    "schemaVersion": 1,
+    "rollup": {
+      "type": "incompatible",
+      "reason": "Uses Rolldown-specific APIs"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": false
+  },
+  "scripts": {
+    "lint": "node --check src/index.js",
+    "test": "node --test test/index.test.mjs"
+  }
+}

package/src/index.js

@@ -0,0 +1,243 @@
+import { createHash } from 'node:crypto';
+import { withMagicString } from 'rolldown-string';
+import { Visitor } from 'rolldown/utils';
+import { ScopedVisitor } from 'oxc-unshadowed-visitor';
+
+const DEFAULT_LIBRARY = ['preact', 'react', 'preact/compat'];
+const SCRIPT_LANG_RE = /\.(c|m)?(t|j)sx?$/;
+const walk = (program, visitor) => new Visitor(visitor).visit(program);
+
+function getLang(id) {
+  if (/\.(c|m)?tsx$/.test(id)) return 'tsx';
+  if (/\.(c|m)?ts$/.test(id)) return 'ts';
+  if (/\.(c|m)?jsx$/.test(id)) return 'jsx';
+  return 'js';
+}
+
+function createFileHash(id) {
+  return createHash('sha256').update(id).digest('hex').slice(0, 16);
+}
+
+function getSimpleParamNames(params) {
+  const names = [];
+  for (const parameter of params) {
+    if (parameter.type === 'Identifier') names.push(parameter.name);
+  }
+  return names;
+}
+
+function getObjectPatternKey(property) {
+  if (property.computed) return null;
+  if (property.key.type === 'Identifier') return property.key.name;
+  if (property.key.type === 'Literal') return String(property.key.value);
+  return null;
+}
+
+function buildContextKey(fileHash, parentKey, count, paramNames) {
+  const base = `${fileHash}${parentKey}${count}`;
+  if (paramNames.length === 0) return `\`${base}\``;
+
+  const suffix = paramNames.map(name => `\${${name}}`).join('');
+  return `\`${base}_${suffix}\``;
+}
+
+export default function prefreshPlugin(options = {}) {
+  const libraries = new Set(options.library || DEFAULT_LIBRARY);
+  let isEnabled = options.enabled;
+  const transformWithMagicString = withMagicString(function (s, id, meta) {
+    const program = meta?.ast || this.parse(s.original, { lang: getLang(id) });
+    const namedImports = new Set();
+    const namespaceImports = new Set();
+
+    for (const node of program.body) {
+      if (node.type !== 'ImportDeclaration') continue;
+      if (!libraries.has(node.source.value)) continue;
+
+      for (const specifier of node.specifiers) {
+        if (specifier.type === 'ImportSpecifier') {
+          const importedName =
+            specifier.imported.type === 'Identifier'
+              ? specifier.imported.name
+              : specifier.imported.value;
+
+          if (importedName === 'createContext') {
+            namedImports.add(specifier.local.name);
+          }
+        } else if (
+          specifier.type === 'ImportDefaultSpecifier' ||
+          specifier.type === 'ImportNamespaceSpecifier'
+        ) {
+          namespaceImports.add(specifier.local.name);
+        }
+      }
+    }
+
+    const trackedNames = [...namedImports, ...namespaceImports];
+    if (trackedNames.length === 0) return;
+
+    const paramNamesStack = [[]];
+    const parentKeyStack = [''];
+    let objectPatternDepth = 0;
+
+    const visitor = new ScopedVisitor({
+      trackedNames,
+      walk,
+      visitor: {
+        FunctionDeclaration(node) {
+          paramNamesStack.push(getSimpleParamNames(node.params));
+        },
+        'FunctionDeclaration:exit'() {
+          paramNamesStack.pop();
+        },
+        FunctionExpression(node) {
+          paramNamesStack.push(getSimpleParamNames(node.params));
+        },
+        'FunctionExpression:exit'() {
+          paramNamesStack.pop();
+        },
+        ArrowFunctionExpression(node) {
+          paramNamesStack.push(getSimpleParamNames(node.params));
+        },
+        'ArrowFunctionExpression:exit'() {
+          paramNamesStack.pop();
+        },
+        VariableDeclarator(node) {
+          if (node.id.type === 'Identifier') {
+            parentKeyStack.push(`$${node.id.name}`);
+          } else {
+            parentKeyStack.push(parentKeyStack[parentKeyStack.length - 1]);
+          }
+        },
+        'VariableDeclarator:exit'() {
+          parentKeyStack.pop();
+        },
+        AssignmentExpression(node) {
+          if (node.left.type === 'Identifier') {
+            parentKeyStack.push(`_${node.left.name}`);
+          } else {
+            parentKeyStack.push(parentKeyStack[parentKeyStack.length - 1]);
+          }
+        },
+        'AssignmentExpression:exit'() {
+          parentKeyStack.pop();
+        },
+        ObjectPattern() {
+          objectPatternDepth++;
+        },
+        'ObjectPattern:exit'() {
+          objectPatternDepth--;
+        },
+        Property(node) {
+          if (objectPatternDepth > 0) {
+            const key = getObjectPatternKey(node);
+            if (key) {
+              parentKeyStack.push(`__${key}`);
+              return;
+            }
+          }
+
+          parentKeyStack.push(parentKeyStack[parentKeyStack.length - 1]);
+        },
+        'Property:exit'() {
+          parentKeyStack.pop();
+        },
+        CallExpression(node, ctx) {
+          const callee = node.callee;
+          const parentKey = parentKeyStack[parentKeyStack.length - 1];
+          const paramNames = paramNamesStack[paramNamesStack.length - 1];
+
+          if (callee.type === 'Identifier' && namedImports.has(callee.name)) {
+            ctx.record({
+              name: callee.name,
+              node,
+              data: { callNode: node, parentKey, paramNames },
+            });
+            return;
+          }
+
+          if (
+            callee.type === 'MemberExpression' &&
+            callee.object.type === 'Identifier' &&
+            namespaceImports.has(callee.object.name)
+          ) {
+            const isCreateContext = callee.computed
+              ? callee.property.type === 'Literal' &&
+                typeof callee.property.value === 'string' &&
+                callee.property.value === 'createContext'
+              : callee.property.type === 'Identifier' &&
+                callee.property.name === 'createContext';
+
+            if (isCreateContext) {
+              ctx.record({
+                name: callee.object.name,
+                node,
+                data: { callNode: node, parentKey, paramNames },
+              });
+            }
+          }
+        },
+      },
+    });
+
+    const records = visitor.walk(program);
+    if (records.length === 0) return;
+
+    const counters = new Map();
+    const fileHash = createFileHash(id);
+
+    for (const record of records) {
+      const { callNode, parentKey, paramNames } = record.data;
+      const counter = (counters.get(parentKey) || 0) + 1;
+      counters.set(parentKey, counter);
+
+      const callee = s.slice(callNode.callee.start, callNode.callee.end);
+      const key = buildContextKey(fileHash, parentKey, counter, paramNames);
+      const firstArg = callNode.arguments[0];
+
+      if (firstArg && firstArg.type !== 'SpreadElement') {
+        const value = s.slice(firstArg.start, firstArg.end);
+        s.update(
+          callNode.start,
+          callNode.end,
+          `Object.assign(${callee}[${key}] || (${callee}[${key}] = ${callee}(${value})), { __: ${value} })`
+        );
+        continue;
+      }
+
+      s.update(
+        callNode.start,
+        callNode.end,
+        `${callee}[${key}] || (${callee}[${key}] = ${callee}())`
+      );
+    }
+  });
+
+  const plugin = {
+    name: 'prefresh-rolldown',
+    enforce: 'pre',
+    configResolved(config) {
+      isEnabled ??= !config.isProduction;
+    },
+    outputOptions() {
+      if ('viteVersion' in this.meta) return;
+      isEnabled ??= process.env.NODE_ENV === 'development';
+    },
+    transform: {
+      filter: {
+        id: SCRIPT_LANG_RE,
+        code: {
+          include: 'createContext',
+        },
+      },
+      handler(code, id, meta) {
+        if (!isEnabled) return;
+
+        return transformWithMagicString.call(this, code, id, meta);
+      },
+    },
+  };
+
+  return plugin;
+}
+
+export const prefresh = prefreshPlugin;