honox 0.0.0 → 0.0.2

package/dist/vite/island-components.js

@@ -0,0 +1,129 @@
+import fs from "fs/promises";
+import _generate from "@babel/generator";
+const generate = _generate.default ?? _generate;
+import { parse } from "@babel/parser";
+import _traverse from "@babel/traverse";
+const traverse = _traverse.default ?? _traverse;
+import {
+  identifier,
+  jsxAttribute,
+  jsxClosingElement,
+  jsxElement,
+  jsxIdentifier,
+  jsxOpeningElement,
+  stringLiteral,
+  callExpression,
+  variableDeclarator,
+  variableDeclaration,
+  functionExpression,
+  blockStatement,
+  returnStatement,
+  jsxSpreadAttribute,
+  jsxExpressionContainer,
+  exportDefaultDeclaration,
+  conditionalExpression,
+  memberExpression
+} from "@babel/types";
+import { COMPONENT_NAME, DATA_SERIALIZED_PROPS } from "../constants.js";
+function addSSRCheck(funcName, componentName, isAsync = false) {
+  const isSSR = memberExpression(
+    memberExpression(identifier("import"), identifier("meta")),
+    identifier("env.SSR")
+  );
+  const serializedProps = callExpression(identifier("JSON.stringify"), [identifier("props")]);
+  const ssrElement = jsxElement(
+    jsxOpeningElement(
+      jsxIdentifier("honox-island"),
+      [
+        jsxAttribute(jsxIdentifier(COMPONENT_NAME), stringLiteral(componentName)),
+        jsxAttribute(jsxIdentifier(DATA_SERIALIZED_PROPS), jsxExpressionContainer(serializedProps))
+      ],
+      false
+    ),
+    jsxClosingElement(jsxIdentifier("honox-island")),
+    [
+      jsxElement(
+        jsxOpeningElement(
+          jsxIdentifier(funcName),
+          [jsxSpreadAttribute(identifier("props"))],
+          false
+        ),
+        jsxClosingElement(jsxIdentifier(funcName)),
+        []
+      )
+    ]
+  );
+  const clientElement = jsxElement(
+    jsxOpeningElement(jsxIdentifier(funcName), [jsxSpreadAttribute(identifier("props"))], false),
+    jsxClosingElement(jsxIdentifier(funcName)),
+    []
+  );
+  const returnStmt = returnStatement(conditionalExpression(isSSR, ssrElement, clientElement));
+  const functionExpr = functionExpression(null, [identifier("props")], blockStatement([returnStmt]));
+  if (isAsync) {
+    functionExpr.async = true;
+  }
+  return functionExpr;
+}
+const transformJsxTags = (contents, componentName) => {
+  const ast = parse(contents, {
+    sourceType: "module",
+    plugins: ["typescript", "jsx"]
+  });
+  if (ast) {
+    traverse(ast, {
+      ExportDefaultDeclaration(path) {
+        if (path.node.declaration.type === "FunctionDeclaration") {
+          const functionId = path.node.declaration.id;
+          if (!functionId) {
+            return;
+          }
+          const isAsync = path.node.declaration.async;
+          const originalFunctionId = identifier(functionId.name + "Original");
+          const originalFunction = functionExpression(
+            null,
+            path.node.declaration.params,
+            path.node.declaration.body
+          );
+          if (isAsync) {
+            originalFunction.async = true;
+          }
+          path.insertBefore(
+            variableDeclaration("const", [variableDeclarator(originalFunctionId, originalFunction)])
+          );
+          const wrappedFunction = addSSRCheck(originalFunctionId.name, componentName, isAsync);
+          const wrappedFunctionId = identifier("Wrapped" + functionId.name);
+          path.replaceWith(
+            variableDeclaration("const", [variableDeclarator(wrappedFunctionId, wrappedFunction)])
+          );
+          path.insertAfter(exportDefaultDeclaration(wrappedFunctionId));
+        }
+      }
+    });
+    const { code } = generate(ast);
+    return code;
+  }
+};
+function islandComponents() {
+  return {
+    name: "transform-island-components",
+    async load(id) {
+      const match = id.match(/\/islands\/(.+?\.tsx)$/);
+      if (match) {
+        const componentName = match[1];
+        const contents = await fs.readFile(id, "utf-8");
+        const code = transformJsxTags(contents, componentName);
+        if (code) {
+          return {
+            code,
+            map: null
+          };
+        }
+      }
+    }
+  };
+}
+export {
+  islandComponents,
+  transformJsxTags
+};

package/dist/vite/remove-elements.d.ts

@@ -0,0 +1,8 @@
+import { Plugin } from 'vite';
+
+type RemoveElementsOptions = {
+    attributes: string[];
+};
+declare function removeElementsPlugin(options: RemoveElementsOptions): Plugin;
+
+export { removeElementsPlugin };

package/dist/vite/remove-elements.js

@@ -0,0 +1,52 @@
+import _generate from "@babel/generator";
+import { parse } from "@babel/parser";
+import _traverse from "@babel/traverse";
+import { HAS_ISLANDS_ID } from "../constants";
+const traverse = _traverse.default ?? _traverse;
+const generate = _generate.default ?? _generate;
+function injectHasIslands() {
+  return {
+    name: "inject-has-islands",
+    transform(code, id) {
+      if (id.endsWith(".tsx") || id.endsWith(".jsx")) {
+        let hasIslandsImport = false;
+        const ast = parse(code, {
+          sourceType: "module",
+          plugins: ["jsx"]
+        });
+        traverse(ast, {
+          ImportDeclaration(path) {
+            if (path.node.source.value.includes("islands/")) {
+              hasIslandsImport = true;
+            }
+          }
+        });
+        if (hasIslandsImport) {
+          const hasIslandsNode = {
+            type: "ExportNamedDeclaration",
+            declaration: {
+              type: "VariableDeclaration",
+              declarations: [
+                {
+                  type: "VariableDeclarator",
+                  id: { type: "Identifier", name: HAS_ISLANDS_ID },
+                  init: { type: "BooleanLiteral", value: true }
+                }
+              ],
+              kind: "const"
+            }
+          };
+          ast.program.body.push(hasIslandsNode);
+        }
+        const output = generate(ast, {}, code);
+        return {
+          code: output.code,
+          map: output.map
+        };
+      }
+    }
+  };
+}
+export {
+  injectHasIslands
+};

package/package.json

@@ -1,6 +1,121 @@
 {
   "name": "honox",
-  "version": "0.0.0",
-  "main": "index.js",
-  "license": "MIT"
-}
+  "version": "0.0.2",
+  "main": "dist/index.js",
+  "type": "module",
+  "scripts": {
+    "test": "bun typecheck && bun test:unit && bun test:integration && bun test:e2e",
+    "test:unit": "vitest --run test/unit",
+    "test:integration": "bun test:integration:api && bun test:integration:hono-jsx",
+    "test:integration:hono-jsx": "vitest run -c ./test/hono-jsx/vitest.config.ts ./test/hono-jsx/integration.test.ts",
+    "test:integration:hono-jsx:watch": "vitest -c ./test/hono-jsx/vitest.config.ts ./test/hono-jsx/integration.test.ts",
+    "test:integration:api": "vitest run -c ./test/api/vitest.config.ts ./test/api/integration.test.ts",
+    "test:e2e": "playwright test -c ./test/hono-jsx/playwright.config.ts ./test/hono-jsx/e2e.test.ts",
+    "typecheck": "tsc --noEmit",
+    "build": "tsup && publint",
+    "watch": "tsup --watch",
+    "lint": "eslint --ext js,ts src test",
+    "lint:fix": "eslint --ext js,ts src test --fix",
+    "format": "prettier --check \"src/**/*.{js,ts}\" \"test/**/*.{js,ts}\"",
+    "format:fix": "prettier --write \"src/**/*.{js,ts}\" \"test/**/*.{js,ts}\"",
+    "prerelease": "bun run test && bun run build",
+    "release": "np"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/types.js"
+    },
+    "./factory": {
+      "types": "./dist/factory/index.d.ts",
+      "import": "./dist/factory/index.js"
+    },
+    "./server": {
+      "types": "./dist/server/index.d.ts",
+      "import": "./dist/server/index.js"
+    },
+    "./client": {
+      "types": "./dist/client/index.d.ts",
+      "import": "./dist/client/index.js"
+    },
+    "./utils/*": {
+      "types": "./dist/utils/*.d.ts",
+      "import": "./dist/utils/*.js"
+    },
+    "./vite": {
+      "types": "./dist/vite/index.d.ts",
+      "import": "./dist/vite/index.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "types": [
+        "./dist/types"
+      ],
+      "factory": [
+        "./dist/factory"
+      ],
+      "server": [
+        "./dist/server"
+      ],
+      "client": [
+        "./dist/client"
+      ],
+      "utils/*": [
+        "./dist/utils/*"
+      ],
+      "vite": [
+        "./dist/vite"
+      ]
+    }
+  },
+  "author": "Yusuke Wada <yusuke@kamawada.com> (https://github.com/yusukebe)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/honojs/honox.git"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "homepage": "https://hono.dev",
+  "dependencies": {
+    "@babel/generator": "^7.23.6",
+    "@babel/parser": "^7.23.6",
+    "@babel/traverse": "^7.23.6",
+    "@babel/types": "^7.23.6",
+    "@hono/vite-dev-server": "^0.5.0"
+  },
+  "devDependencies": {
+    "@hono/eslint-config": "^0.0.4",
+    "@mdx-js/rollup": "^3.0.0",
+    "@playwright/test": "^1.41.0",
+    "@types/babel__generator": "^7",
+    "@types/babel__traverse": "^7",
+    "@types/node": "^20.10.5",
+    "eslint": "^8.56.0",
+    "glob": "^10.3.10",
+    "hono": "4.0.0-rc.4",
+    "np": "7.7.0",
+    "prettier": "^3.1.1",
+    "publint": "^0.2.7",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3",
+    "vite": "^5.0.12",
+    "vitest": "^1.2.1"
+  },
+  "engines": {
+    "node": ">=18.14.1"
+  },
+  "optionalDependencies": {
+    "@rollup/rollup-linux-x64-gnu": "^4.9.6"
+  }
+}