@pyreon/vue-compat 0.1.0

package/lib/types/index2.d.ts

@@ -0,0 +1,189 @@
+import { ComponentFn, Fragment, Props, VNodeChild, h as pyreonH } from "@pyreon/core";
+import { batch } from "@pyreon/reactivity";
+
+//#region src/index.d.ts
+declare const V_IS_REF: unique symbol;
+interface Ref<T = unknown> {
+  value: T;
+  readonly [V_IS_REF]: true;
+}
+/**
+ * Creates a reactive ref wrapping the given value.
+ * Access via `.value` — reads track, writes trigger.
+ *
+ * Difference from Vue: backed by a Pyreon signal. No `__v_isShallow` distinction
+ * at runtime since Pyreon signals are always shallow (deep reactivity is via stores).
+ */
+declare function ref<T>(value: T): Ref<T>;
+/**
+ * Creates a shallow ref — same as `ref()` in Pyreon since signals are inherently shallow.
+ *
+ * Difference from Vue: identical to `ref()` — Pyreon signals don't perform deep conversion.
+ */
+declare function shallowRef<T>(value: T): Ref<T>;
+/**
+ * Force trigger a ref's subscribers, even if the value hasn't changed.
+ */
+declare function triggerRef<T>(r: Ref<T>): void;
+/**
+ * Returns `true` if the value is a ref (created by `ref()` or `computed()`).
+ */
+declare function isRef(val: unknown): val is Ref;
+/**
+ * Unwraps a ref: if it has `.value`, return `.value`; otherwise return as-is.
+ */
+declare function unref<T>(r: T | Ref<T>): T;
+interface ComputedRef<T = unknown> extends Ref<T> {
+  readonly value: T;
+}
+/**
+ * Creates a computed ref. Supports both readonly and writable forms:
+ *   - `computed(() => value)` — readonly
+ *   - `computed({ get: () => value, set: (v) => ... })` — writable
+ *
+ * Backed by Pyreon's `computed()`, wrapped in a `.value` accessor.
+ */
+declare function computed<T>(fnOrOptions: (() => T) | {
+  get: () => T;
+  set: (value: T) => void;
+}): ComputedRef<T>;
+/**
+ * Creates a deeply reactive proxy from a plain object.
+ * Backed by Pyreon's `createStore()`.
+ *
+ * Difference from Vue: uses Pyreon's fine-grained per-property signals.
+ * Direct mutation triggers only affected signals.
+ */
+declare function reactive<T extends object>(obj: T): T;
+/**
+ * Creates a shallow reactive proxy.
+ * In Pyreon, `createStore` is already per-property (not deeply recursive for primitives),
+ * but nested objects will be wrapped. For truly shallow behavior, use individual refs.
+ *
+ * Difference from Vue: backed by `createStore()` — same as `reactive()` in practice.
+ */
+declare function shallowReactive<T extends object>(obj: T): T;
+/**
+ * Returns a readonly proxy that throws on mutation attempts.
+ *
+ * Difference from Vue: uses a simple Proxy with a set trap that throws,
+ * rather than Vue's full readonly reactive system.
+ */
+declare function readonly<T extends object>(obj: T): Readonly<T>;
+/**
+ * Returns the raw (unwrapped) object behind a reactive or readonly proxy.
+ *
+ * Difference from Vue: only works for objects created via `reactive()` or `readonly()`.
+ */
+declare function toRaw<T extends object>(proxy: T): T;
+/**
+ * Creates a ref linked to a property of a reactive object.
+ * Reading/writing the ref's `.value` reads/writes the original property.
+ */
+declare function toRef<T extends object, K extends keyof T>(obj: T, key: K): Ref<T[K]>;
+/**
+ * Converts all properties of a reactive object into individual refs.
+ * Each ref is linked to the original property (not a copy).
+ */
+declare function toRefs<T extends object>(obj: T): { [K in keyof T]: Ref<T[K]> };
+interface WatchOptions {
+  /** Call the callback immediately with current value. Default: false */
+  immediate?: boolean;
+  /** Ignored in Pyreon — dependencies are tracked automatically. */
+  deep?: boolean;
+}
+type WatchSource<T> = Ref<T> | (() => T);
+/**
+ * Watches a reactive source and calls `cb` when it changes.
+ * Tracks old and new values.
+ *
+ * Difference from Vue: `deep` option is ignored — Pyreon tracks dependencies automatically.
+ * Returns a stop function to dispose the watcher.
+ */
+declare function watch<T>(source: WatchSource<T>, cb: (newValue: T, oldValue: T | undefined) => void, options?: WatchOptions): () => void;
+/**
+ * Runs the given function reactively — re-executes whenever its tracked
+ * dependencies change.
+ *
+ * Difference from Vue: identical to Pyreon's `effect()`.
+ * Returns a stop function.
+ */
+declare function watchEffect(fn: () => void): () => void;
+/**
+ * Registers a callback to run after the component is mounted.
+ *
+ * Difference from Vue: maps directly to Pyreon's `onMount()`.
+ * In Pyreon there is no distinction between beforeMount and mounted.
+ */
+declare function onMounted(fn: () => void): void;
+/**
+ * Registers a callback to run before the component is unmounted.
+ *
+ * Difference from Vue: maps to Pyreon's `onUnmount()`.
+ * In Pyreon there is no distinction between beforeUnmount and unmounted.
+ */
+declare function onUnmounted(fn: () => void): void;
+/**
+ * Registers a callback to run after a reactive update.
+ *
+ * Difference from Vue: maps to Pyreon's `onUpdate()`.
+ */
+declare function onUpdated(fn: () => void): void;
+/**
+ * Registers a callback to run before mount.
+ * In Pyreon there is no pre-mount phase — maps to `onMount()`.
+ */
+declare function onBeforeMount(fn: () => void): void;
+/**
+ * Registers a callback to run before unmount.
+ * In Pyreon there is no pre-unmount phase — maps to `onUnmount()`.
+ */
+declare function onBeforeUnmount(fn: () => void): void;
+/**
+ * Returns a Promise that resolves after all pending reactive updates have flushed.
+ *
+ * Difference from Vue: identical to Pyreon's `nextTick()`.
+ */
+declare function nextTick(): Promise<void>;
+/**
+ * Provides a value to all descendant components.
+ *
+ * Difference from Vue: backed by Pyreon's context stack (pushContext/popContext).
+ * Must be called during component setup. The value is scoped to the component
+ * tree — not globally shared.
+ */
+declare function provide<T>(key: string | symbol, value: T): void;
+/**
+ * Injects a value provided by an ancestor component.
+ *
+ * Difference from Vue: backed by Pyreon's context system (useContext).
+ */
+declare function inject<T>(key: string | symbol, defaultValue?: T): T | undefined;
+interface ComponentOptions<P extends Props = Props> {
+  /** The setup function — called once during component initialization. */
+  setup: (props: P) => (() => VNodeChild) | VNodeChild;
+  /** Optional name for debugging. */
+  name?: string;
+}
+/**
+ * Defines a component using Vue 3 Composition API style.
+ * Only supports the `setup()` function — Options API is not supported.
+ *
+ * Difference from Vue: returns a Pyreon `ComponentFn`. No template/render option —
+ * the setup function should return a render function or VNode directly.
+ */
+declare function defineComponent<P extends Props = Props>(options: ComponentOptions<P> | ((props: P) => VNodeChild)): ComponentFn<P>;
+interface App {
+  /** Mount the application into a DOM element. Returns an unmount function. */
+  mount(el: string | Element): () => void;
+}
+/**
+ * Creates a Pyreon application instance — Vue 3 `createApp()` compatible.
+ *
+ * Difference from Vue: does not support plugins, directives, or global config.
+ * The component receives `props` if provided.
+ */
+declare function createApp(component: ComponentFn, props?: Props): App;
+//#endregion
+export { ComputedRef, Fragment, Ref, WatchOptions, batch, computed, createApp, defineComponent, pyreonH as h, inject, isRef, nextTick, onBeforeMount, onBeforeUnmount, onMounted, onUnmounted, onUpdated, provide, reactive, readonly, ref, shallowReactive, shallowRef, toRaw, toRef, toRefs, triggerRef, unref, watch, watchEffect };
+//# sourceMappingURL=index2.d.ts.map

package/lib/types/index2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index2.d.ts","names":[],"sources":["../../src/index.ts"],"mappings":";;;;cA4CM,QAAA;AAAA,UAMW,GAAA;EACf,KAAA,EAAO,CAAA;EAAA,UACG,QAAA;AAAA;;;;;;;;iBAUI,GAAA,GAAA,CAAO,KAAA,EAAO,CAAA,GAAI,GAAA,CAAI,CAAA;AAqBtC;;;;;AAAA,iBAAgB,UAAA,GAAA,CAAc,KAAA,EAAO,CAAA,GAAI,GAAA,CAAI,CAAA;;;;iBAO7B,UAAA,GAAA,CAAc,CAAA,EAAG,GAAA,CAAI,CAAA;;;;iBAarB,KAAA,CAAM,GAAA,YAAe,GAAA,IAAO,GAAA;;AAb5C;;iBAsBgB,KAAA,GAAA,CAAS,CAAA,EAAG,CAAA,GAAI,GAAA,CAAI,CAAA,IAAK,CAAA;AAAA,UAMxB,WAAA,sBAAiC,GAAA,CAAI,CAAA;EAAA,SAC3C,KAAA,EAAO,CAAA;AAAA;;;;;AAhBlB;;;iBA0BgB,QAAA,GAAA,CACd,WAAA,SAAoB,CAAA;EAAO,GAAA,QAAW,CAAA;EAAG,GAAA,GAAM,KAAA,EAAO,CAAA;AAAA,IACrD,WAAA,CAAY,CAAA;;;AAnBf;;;;;iBA+CgB,QAAA,kBAAA,CAA2B,GAAA,EAAK,CAAA,GAAI,CAAA;;;;;;;;iBAcpC,eAAA,kBAAA,CAAkC,GAAA,EAAK,CAAA,GAAI,CAAA;;;;AAvD3D;;;iBAoEgB,QAAA,kBAAA,CAA2B,GAAA,EAAK,CAAA,GAAI,QAAA,CAAS,CAAA;;;;;;iBAwB7C,KAAA,kBAAA,CAAwB,KAAA,EAAO,CAAA,GAAI,CAAA;;;;;iBAenC,KAAA,mCAAwC,CAAA,CAAA,CAAG,GAAA,EAAK,CAAA,EAAG,GAAA,EAAK,CAAA,GAAI,GAAA,CAAI,CAAA,CAAE,CAAA;AAhGlF;;;;AAAA,iBAiHgB,MAAA,kBAAA,CAAyB,GAAA,EAAK,CAAA,iBAAkB,CAAA,GAAI,GAAA,CAAI,CAAA,CAAE,CAAA;AAAA,UAUzD,YAAA;EAzHH;EA2HZ,SAAA;EA7HuB;EA+HvB,IAAA;AAAA;AAAA,KAGG,WAAA,MAAiB,GAAA,CAAI,CAAA,WAAY,CAAA;;;;;;;;iBAStB,KAAA,GAAA,CACd,MAAA,EAAQ,WAAA,CAAY,CAAA,GACpB,EAAA,GAAK,QAAA,EAAU,CAAA,EAAG,QAAA,EAAU,CAAA,uBAC5B,OAAA,GAAU,YAAA;AAhHZ;;;;;;;AAAA,iBAkJgB,WAAA,CAAY,EAAA;;;AApI5B;;;;iBAiJgB,SAAA,CAAU,EAAA;;;;;;AApI1B;iBAiJgB,WAAA,CAAY,EAAA;;;;;;iBASZ,SAAA,CAAU,EAAA;;;;;iBAQV,aAAA,CAAc,EAAA;;;AA1I9B;;iBAqJgB,eAAA,CAAgB,EAAA;;;;;;iBAWhB,QAAA,CAAA,GAAY,OAAA;;AAjJ5B;;;;;;iBAwKgB,OAAA,GAAA,CAAW,GAAA,mBAAsB,KAAA,EAAO,CAAA;;;;;;iBAWxC,MAAA,GAAA,CAAU,GAAA,mBAAsB,YAAA,GAAe,CAAA,GAAI,CAAA;AAAA,UAQzD,gBAAA,WAA2B,KAAA,GAAQ,KAAA;EA3LmB;EA6L9D,KAAA,GAAQ,KAAA,EAAO,CAAA,YAAa,UAAA,IAAc,UAAA;EA7L4B;EA+LtE,IAAA;AAAA;;;;;AA9KF;;;iBAwLgB,eAAA,WAA0B,KAAA,GAAQ,KAAA,CAAA,CAChD,OAAA,EAAS,gBAAA,CAAiB,CAAA,MAAO,KAAA,EAAO,CAAA,KAAM,UAAA,IAC7C,WAAA,CAAY,CAAA;AAAA,UA0BL,GAAA;EApN6D;EAsNrE,KAAA,CAAM,EAAA,WAAa,OAAA;AAAA;;;;;;;iBASL,SAAA,CAAU,SAAA,EAAW,WAAA,EAAa,KAAA,GAAQ,KAAA,GAAQ,GAAA"}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@pyreon/vue-compat",
+  "version": "0.1.0",
+  "description": "Vue 3-compatible Composition API shim for Pyreon — write Vue-style code that runs on Pyreon's reactive engine",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pyreon/pyreon.git",
+    "directory": "packages/vue-compat"
+  },
+  "homepage": "https://github.com/pyreon/pyreon/tree/main/packages/vue-compat#readme",
+  "bugs": {
+    "url": "https://github.com/pyreon/pyreon/issues"
+  },
+  "files": [
+    "lib",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "type": "module",
+  "main": "./lib/index.js",
+  "module": "./lib/index.js",
+  "types": "./lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "bun": "./src/index.ts",
+      "import": "./lib/index.js",
+      "types": "./lib/types/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "vl_rolldown_build",
+    "dev": "vl_rolldown_build-watch",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "bun run build"
+  },
+  "dependencies": {
+    "@pyreon/core": "workspace:*",
+    "@pyreon/reactivity": "workspace:*",
+    "@pyreon/runtime-dom": "workspace:*"
+  },
+  "devDependencies": {
+    "@happy-dom/global-registrator": "^20.8.3",
+    "happy-dom": "^20.8.3"
+  }
+}