@meekojs/meeko 0.0.0-stage → 0.0.2

package/dist/reactivity.js

@@ -0,0 +1,151 @@
+const writableSignals = new WeakSet();
+const derivedSignals = new WeakSet();
+/** Identifica señales editables creadas por Meeko para conservarlas durante HMR. */
+export function isWritableSignal(value) {
+    return typeof value === "object" && value !== null && writableSignals.has(value) && !derivedSignals.has(value);
+}
+let activeObserver;
+let activeOwner;
+let batchDepth = 0;
+let flushing = false;
+const pending = new Set();
+function detach(observer) {
+    for (const dependency of observer.dependencies)
+        dependency.subscribers.delete(observer);
+    observer.dependencies.clear();
+}
+function flush() {
+    if (flushing || batchDepth > 0)
+        return;
+    flushing = true;
+    try {
+        let iterations = 0;
+        while (pending.size > 0) {
+            if (++iterations > 1000)
+                throw new Error("Reactive update cycle exceeded 1000 iterations");
+            const observers = [...pending];
+            pending.clear();
+            for (const observer of observers)
+                if (!observer.disposed)
+                    observer.run();
+        }
+    }
+    finally {
+        flushing = false;
+    }
+}
+/** Crea un valor observable. Las escrituras iguales no notifican cambios. */
+export function signal(initial) {
+    let current = initial;
+    const subscribers = new Set();
+    const result = {
+        subscribers,
+        get value() {
+            if (activeObserver) {
+                subscribers.add(activeObserver);
+                activeObserver.dependencies.add(result);
+            }
+            return current;
+        },
+        set value(next) {
+            if (Object.is(current, next))
+                return;
+            current = next;
+            for (const observer of subscribers)
+                pending.add(observer);
+            flush();
+        },
+    };
+    writableSignals.add(result);
+    return result;
+}
+/** Ejecuta una función cuando cambian las señales leídas por ella. */
+export function effect(fn) {
+    const owner = activeOwner;
+    const observer = {
+        dependencies: new Set(),
+        disposed: false,
+        run() {
+            detach(observer);
+            const previous = activeObserver;
+            const previousOwner = activeOwner;
+            activeObserver = observer;
+            activeOwner = owner;
+            try {
+                fn();
+            }
+            finally {
+                activeObserver = previous;
+                activeOwner = previousOwner;
+            }
+        },
+    };
+    owner?.observers.add(observer);
+    observer.run();
+    return () => {
+        observer.disposed = true;
+        pending.delete(observer);
+        detach(observer);
+        owner?.observers.delete(observer);
+    };
+}
+/** Deriva un valor de otras señales y lo actualiza cuando cambian. */
+export function computed(fn) {
+    const result = signal(undefined);
+    derivedSignals.add(result);
+    effect(() => {
+        result.value = fn();
+    });
+    return result;
+}
+/** Agrupa varias escrituras en una sola ronda de notificaciones. */
+export function batch(fn) {
+    batchDepth++;
+    try {
+        return fn();
+    }
+    finally {
+        batchDepth--;
+        flush();
+    }
+}
+/** Lee señales sin registrar dependencias en el observador activo. */
+export function untrack(fn) {
+    const previous = activeObserver;
+    activeObserver = undefined;
+    try {
+        return fn();
+    }
+    finally {
+        activeObserver = previous;
+    }
+}
+/** Asocia efectos a una instancia y entrega una función para liberarlos. */
+export function createRoot(fn) {
+    const owner = { observers: new Set(), children: new Set(), parent: activeOwner };
+    const previous = activeOwner;
+    activeOwner = owner;
+    const dispose = () => {
+        for (const child of [...owner.children])
+            child();
+        owner.children.clear();
+        for (const observer of owner.observers) {
+            observer.disposed = true;
+            pending.delete(observer);
+            detach(observer);
+        }
+        owner.observers.clear();
+        owner.parent?.children.delete(dispose);
+    };
+    owner.parent?.children.add(dispose);
+    try {
+        return fn(dispose);
+    }
+    catch (error) {
+        dispose();
+        throw error;
+    }
+    finally {
+        activeOwner = previous;
+    }
+}

package/dist/server.d.ts

@@ -0,0 +1,8 @@
+/** Escapa texto dinámico antes de insertarlo en HTML generado por SSR. */
+export declare function escapeHtml(value: unknown): string;
+/** Convierte un valor de atributo dinámico en su forma DOM; null lo elimina. */
+export declare function attributeValue(name: string, value: unknown): string | null;
+/** Genera un atributo HTML dinámico con escape seguro para SSR. */
+export declare function renderAttribute(name: string, value: unknown): string;
+/** Serializa estado y props transferibles al navegador, rechazando valores ambiguos. */
+export declare function serializeJson(value: unknown): string;

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,81 @@
 {
   "name": "@meekojs/meeko",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.0.2",
+  "packageManager": "pnpm@12.14.0",
+  "description": "Typed .meeko component engine with SSR, hydration, signals, Vite, and DevTools.",
+  "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", "devtools"],
+  "publishConfig": { "access": "public" },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./vite": {
+      "types": "./dist/vite.d.ts",
+      "default": "./dist/vite.js"
+    },
+    "./internal": {
+      "types": "./dist/internal.d.ts",
+      "default": "./dist/internal.js"
+    },
+    "./devtools-ui": {
+      "types": "./dist/devtools-ui/index.d.ts",
+      "default": "./dist/devtools-ui/index.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 && node dist/cli.js compile benchmarks/cases/TreeLeaf.meeko benchmarks/cases/TreeLeaf.generated.ts && node dist/cli.js compile benchmarks/cases/TreeBranch.meeko benchmarks/cases/TreeBranch.generated.ts && node dist/cli.js compile benchmarks/cases/Tree.meeko benchmarks/cases/Tree.generated.ts && node dist/cli.js compile benchmarks/cases/List.meeko benchmarks/cases/List.generated.ts && node dist/cli.js compile benchmarks/cases/Navigation.meeko benchmarks/cases/Navigation.generated.ts && tsc -p tsconfig.benchmark.json --noEmit",
+    "benchmark": "pnpm run build && pnpm run benchmark:check && node --expose-gc --import tsx benchmarks/run.ts",
+    "benchmark:scenarios": "pnpm run build && pnpm run benchmark:check && node --expose-gc --import tsx benchmarks/scenarios.ts",
+    "package:smoke": "pwsh -NoProfile -File tests/package-consumer.ps1",
+    "devtools:check": "node --test tools/devtools-extension/tests/*.test.js && tsc -p tools/devtools-extension/tsconfig.json --noEmit",
+    "verify": "pnpm run check && pnpm run test && pnpm run devtools:check && 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"
+  }
+}