@meekojs/meeko 0.0.0-stage → 0.0.1

package/dist/server.js

@@ -0,0 +1,79 @@
+/** Escapa texto dinámico antes de insertarlo en HTML generado por SSR. */
+export function escapeHtml(value) {
+    return String(value)
+        .replaceAll("&", "&")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&#39;");
+}
+const booleanAttributes = new Set(["allowfullscreen", "async", "autofocus", "autoplay", "checked", "controls", "default", "defer", "disabled", "formnovalidate", "hidden", "inert", "ismap", "loop", "multiple", "muted", "nomodule", "novalidate", "open", "playsinline", "readonly", "required", "reversed", "selected"]);
+/** Convierte un valor de atributo dinámico en su forma DOM; null lo elimina. */
+export function attributeValue(name, value) {
+    if (booleanAttributes.has(name))
+        return value ? "" : null;
+    if (value === null || value === undefined || value === false)
+        return null;
+    return String(value);
+}
+/** Genera un atributo HTML dinámico con escape seguro para SSR. */
+export function renderAttribute(name, value) {
+    if (!/^[a-zA-Z_:][a-zA-Z0-9_:.-]*$/.test(name))
+        throw new TypeError(`Invalid attribute name: ${name}`);
+    const resolved = attributeValue(name, value);
+    return resolved === null ? "" : ` ${name}="${escapeHtml(resolved)}"`;
+}
+function assertSerializable(value, path, ancestors) {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return;
+    if (typeof value === "number") {
+        if (Number.isFinite(value))
+            return;
+        throw new TypeError(`Non-finite number at ${path}`);
+    }
+    if (typeof value !== "object")
+        throw new TypeError(`Non-serializable value at ${path}`);
+    if (ancestors.has(value))
+        throw new TypeError(`Circular reference at ${path}`);
+    const prototype = Object.getPrototypeOf(value);
+    if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null) {
+        throw new TypeError(`Non-plain object at ${path}`);
+    }
+    if (Object.hasOwn(value, "toJSON"))
+        throw new TypeError(`Custom toJSON at ${path}`);
+    if (Array.isArray(value)) {
+        for (let index = 0; index < value.length; index++) {
+            if (!Object.hasOwn(value, index))
+                throw new TypeError(`Sparse array at ${path}[${index}]`);
+        }
+    }
+    ancestors.add(value);
+    try {
+        for (const key of Reflect.ownKeys(value)) {
+            if (typeof key !== "string")
+                throw new TypeError(`Symbol key at ${path}`);
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            if (!descriptor?.enumerable)
+                continue;
+            if (!("value" in descriptor))
+                throw new TypeError(`Accessor property at ${path}.${key}`);
+            assertSerializable(descriptor.value, `${path}.${key}`, ancestors);
+        }
+    }
+    finally {
+        ancestors.delete(value);
+    }
+}
+/** Serializa estado y props transferibles al navegador, rechazando valores ambiguos. */
+export function serializeJson(value) {
+    assertSerializable(value, "$", new WeakSet());
+    const json = JSON.stringify(value);
+    if (json === undefined)
+        throw new TypeError("Value cannot be serialized to JSON");
+    return json
+        .replaceAll("<", "\\u003c")
+        .replaceAll(">", "\\u003e")
+        .replaceAll("&", "\\u0026")
+        .replaceAll("\u2028", "\\u2028")
+        .replaceAll("\u2029", "\\u2029");
+}

package/dist/types.d.ts

@@ -0,0 +1,2 @@
+/** Genera declaraciones TypeScript para un componente y sus imports .meeko relativos. */
+export declare function generateTypes(source: string, filename: string): Promise<string[]>;

package/dist/types.js

@@ -0,0 +1,38 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import ts from "@typescript/typescript6";
+import { compile } from "./compiler.js";
+/** Genera declaraciones TypeScript para un componente y sus imports .meeko relativos. */
+export async function generateTypes(source, filename) {
+    if (!filename.endsWith(".meeko"))
+        throw new TypeError("Type generation requires a .meeko input file");
+    const declarations = new Map();
+    async function collect(content, path) {
+        if (declarations.has(path))
+            return;
+        const generated = compile(content, path).code;
+        const result = ts.transpileDeclaration(generated, {
+            fileName: `${path}.ts`,
+            compilerOptions: { declaration: true, emitDeclarationOnly: true },
+        });
+        const error = result.diagnostics?.find((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error);
+        if (error)
+            throw new Error(ts.flattenDiagnosticMessageText(error.messageText, "\n"));
+        declarations.set(path, result.outputText);
+        for (const match of generated.matchAll(/\b(?:from\s*|import\s*)["']([^"']+\.meeko)["']/g)) {
+            const specifier = match[1];
+            if (!specifier.startsWith("."))
+                continue;
+            const child = resolve(dirname(path), specifier);
+            await collect(await readFile(child, "utf8"), child);
+        }
+    }
+    await collect(source, resolve(filename));
+    const outputs = [];
+    for (const [path, declaration] of declarations) {
+        const output = path.replace(/\.meeko$/, ".d.meeko.ts");
+        await writeFile(output, declaration, "utf8");
+        outputs.push(output);
+    }
+    return outputs;
+}

package/dist/vite.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "vite";
+/** Transforma componentes .meeko para Vite, tanto en cliente como en SSR. */
+export declare function meeko(): Plugin;

package/dist/vite.js

@@ -0,0 +1,47 @@
+import { createHash } from "node:crypto";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { normalizePath, transformWithOxc } from "vite";
+import { compile } from "./compiler.js";
+const stylePrefix = "\0virtual:meeko-style:";
+const runtimeDirectory = `${normalizePath(dirname(fileURLToPath(import.meta.url)))}/`;
+/** Transforma componentes .meeko para Vite, tanto en cliente como en SSR. */
+export function meeko() {
+    let isDev = false;
+    const styles = new Map();
+    return {
+        name: "meeko:components",
+        enforce: "pre",
+        configResolved(config) {
+            isDev = config.command === "serve";
+        },
+        resolveId(id) {
+            if (id.startsWith("virtual:meeko-style:"))
+                return `\0${id}`;
+            return null;
+        },
+        load(id) {
+            if (!id.startsWith(stylePrefix) || !id.endsWith(".css"))
+                return null;
+            return styles.get(id) ?? null;
+        },
+        async transform(source, id) {
+            if (!id.endsWith(".meeko"))
+                return null;
+            const filename = normalizePath(resolve(id));
+            const result = compile(source, filename, { hot: isDev });
+            const styleId = `${stylePrefix}${createHash("sha256").update(filename).update("\0").update(result.css).digest("hex")}.css`;
+            if (result.css)
+                styles.set(styleId, result.css);
+            const cssImport = result.css ? `\nimport ${JSON.stringify(styleId.slice(1))};` : "";
+            const hotCode = isDev ? `\nif (import.meta.hot) {\n  __meeko.enableHotModule(__hotId);\n  import.meta.hot.accept((next) => { if (next) __meeko.replaceHotModule(__hotId, next); });\n}\n` : "";
+            return transformWithOxc(`${result.code}${cssImport}${hotCode}`, `${filename}.ts`, { lang: "ts" });
+        },
+        handleHotUpdate({ file, server }) {
+            if (!normalizePath(file).startsWith(runtimeDirectory))
+                return;
+            server.ws.send({ type: "full-reload" });
+            return [];
+        },
+    };
+}

package/package.json

@@ -1,6 +1,71 @@
 {
   "name": "@meekojs/meeko",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.0.1",
+  "packageManager": "pnpm@12.14.0",
+  "description": "Typed .meeko component engine with SSR, hydration, signals, and Vite integration.",
+  "license": "MIT",
+  "type": "module",
+  "files": ["dist/"],
+  "types": "./dist/index.d.ts",
+  "repository": { "type": "git", "url": "git+https://github.com/meekojs/meeko.git" },
+  "homepage": "https://github.com/meekojs/meeko#readme",
+  "bugs": { "url": "https://github.com/meekojs/meeko/issues" },
+  "keywords": ["meeko", "components", "ssr", "hydration", "reactivity", "vite", "typescript"],
+  "publishConfig": { "access": "public" },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./vite": {
+      "types": "./dist/vite.d.ts",
+      "default": "./dist/vite.js"
+    }
+  },
+  "bin": {
+    "meeko": "dist/cli.js"
+  },
+  "scripts": {
+    "prepack": "tsc -p tsconfig.build.json",
+    "build": "tsc -p tsconfig.build.json",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "test": "pnpm run build && pnpm run example:compile && tsx --test tests/*.test.ts",
+    "example:compile": "node dist/cli.js compile examples/counter/Counter.meeko examples/counter/Counter.generated.ts && node dist/cli.js compile examples/attributes/Attributes.meeko examples/attributes/Attributes.generated.ts && node dist/cli.js compile examples/regions/Regions.meeko examples/regions/Regions.generated.ts && node dist/cli.js compile examples/primitives/Primitives.meeko examples/primitives/Primitives.generated.ts",
+    "example:bundle": "pnpm run build && pnpm run example:compile && esbuild examples/counter/client.ts --bundle --format=esm --platform=browser --target=es2022 --outfile=examples/counter/client.bundle.js",
+    "example:check": "tsc -p examples/counter/tsconfig.json --noEmit",
+    "example:serve": "pnpm run example:bundle && tsx examples/counter/server.ts",
+    "vite:dev": "vite examples/vite --config examples/vite/vite.config.ts",
+    "vite:types": "pnpm run build && node dist/cli.js types examples/counter/Counter.meeko && node dist/cli.js types examples/regions/Regions.meeko && node dist/cli.js types examples/vite/Hot.meeko && node dist/cli.js types examples/nested/Parent.meeko && tsc -p examples/vite/tsconfig.json --noEmit",
+    "vite:build": "vite build examples/vite --config examples/vite/vite.config.ts",
+    "e2e": "pnpm run example:bundle && pnpm run vite:build && tsx --test tests/browser.e2e.ts",
+    "benchmark:check": "pnpm run example:compile && tsc -p tsconfig.benchmark.json --noEmit",
+    "benchmark": "pnpm run build && pnpm run benchmark:check && node --expose-gc --import tsx benchmarks/run.ts",
+    "package:smoke": "pwsh -NoProfile -File tests/package-consumer.ps1",
+    "verify": "pnpm run check && pnpm run test && pnpm run example:check && tsc -p tsconfig.test.json --noEmit && pnpm run vite:types && pnpm run benchmark:check && pnpm run vite:build"
+  },
+  "dependencies": {
+    "@typescript/typescript6": "6.0.2",
+    "parse5": "^8.0.0",
+    "postcss": "^8.5.31",
+    "postcss-selector-parser": "^7.1.7",
+    "typescript": "7.0.2"
+  },
+  "peerDependencies": {
+    "vite": "^8.3.5"
+  },
+  "peerDependenciesMeta": {
+    "vite": { "optional": true }
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "esbuild": "0.28.2",
+    "happy-dom": "^20.0.0",
+    "playwright-core": "1.64.1",
+    "tsx": "^4.20.0",
+    "vite": "8.3.5",
+    "vue": "3.5.44"
+  },
+  "engines": {
+    "node": ">=24"
+  }
+}