@skewedaspect/sage-vue 0.8.0

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './packages/sage-vue/src/index'
+export {}

package/dist/packages/sage-vue/src/index.d.ts

@@ -0,0 +1,7 @@
+export { default as SageCanvas } from './sageCanvas.vue';
+export { useSageEngine } from "./useSageEngine.d.ts";
+export { useSageEvent } from "./useSageEvent.d.ts";
+export { useSageAction } from "./useSageAction.d.ts";
+export { useSageState } from "./useSageState.d.ts";
+export { useSageTimer } from "./useSageTimer.d.ts";
+export { SAGE_ENGINE_KEY } from "./symbols.d.ts";

package/dist/packages/sage-vue/src/sageCanvas.vue.d.ts

@@ -0,0 +1,42 @@
+import { GameEngine, GameEntityDefinition, SageOptions } from "../../../src/sage.d.ts";
+type __VLS_Props = {
+    entityDefinitions?: GameEntityDefinition[];
+    options?: SageOptions;
+    engine?: GameEngine;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {
+            loading: boolean;
+            error: unknown;
+            engine: GameEngine | null;
+        }): any;
+    };
+    refs: {
+        containerRef: HTMLDivElement;
+        canvasRef: HTMLCanvasElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "engine-ready": (engine: GameEngine) => any;
+    "engine-error": (error: unknown) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onEngine-ready"?: ((engine: GameEngine) => any) | undefined;
+    "onEngine-error"?: ((error: unknown) => any) | undefined;
+}>, {
+    options: SageOptions;
+    entityDefinitions: GameEntityDefinition[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    containerRef: HTMLDivElement;
+    canvasRef: HTMLCanvasElement;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/packages/sage-vue/src/symbols.d.ts

@@ -0,0 +1,3 @@
+import { InjectionKey, ShallowRef } from 'vue';
+import { GameEngine } from "../../../src/sage.d.ts";
+export declare const SAGE_ENGINE_KEY: InjectionKey<ShallowRef<GameEngine | null>>;

package/dist/packages/sage-vue/src/useSageAction.d.ts

@@ -0,0 +1,2 @@
+import { Ref } from 'vue';
+export declare function useSageAction(actionName: string): Ref<boolean | number>;

package/dist/packages/sage-vue/src/useSageEngine.d.ts

@@ -0,0 +1,8 @@
+import { ComputedRef, ShallowRef } from 'vue';
+import { GameEngine, GameEventBus } from "../../../src/sage.d.ts";
+interface SageEngineContext {
+    engine: ShallowRef<GameEngine | null>;
+    eventBus: ComputedRef<GameEventBus | null>;
+}
+export declare function useSageEngine(): SageEngineContext;
+export {};

package/dist/packages/sage-vue/src/useSageEvent.d.ts

@@ -0,0 +1,4 @@
+import { GameEvent } from "../../../src/sage.d.ts";
+type EventHandler = (event: GameEvent) => void | Promise<void>;
+export declare function useSageEvent(pattern: string | RegExp, handler: EventHandler): void;
+export {};

package/dist/packages/sage-vue/src/useSageState.d.ts

@@ -0,0 +1,6 @@
+import { Ref } from 'vue';
+/**
+ * Returns a reactive ref synced to an entity's state. If `key` is provided, tracks only that property; otherwise
+ * tracks the entire state object.
+ */
+export declare function useSageState<T = unknown>(entityId: string, key?: string): Ref<T>;

package/dist/packages/sage-vue/src/useSageTimer.d.ts

@@ -0,0 +1,12 @@
+import { CooldownHandle } from "../../../src/sage.d.ts";
+interface SageTimerComposable {
+    delay: (ms: number, callback: () => void) => () => void;
+    interval: (ms: number, callback: () => void) => () => void;
+    cooldown: (ms: number) => CooldownHandle;
+}
+/**
+ * Returns pause-aware timer functions (delay, interval, cooldown) from the game engine. All active timers are
+ * automatically cancelled when the component unmounts.
+ */
+export declare function useSageTimer(): SageTimerComposable;
+export {};

package/dist/sage-vue.css

@@ -0,0 +1 @@
+.sage-container[data-v-7932fefe]{position:relative;width:100%;height:100%}.sage-canvas[data-v-7932fefe]{display:block;width:100%;height:100%}.sage-overlay[data-v-7932fefe]{position:absolute;top:0;left:0;width:100%;height:100%;pointer-events:none}.sage-overlay[data-v-7932fefe] *{pointer-events:auto}

package/dist/sage-vue.js

@@ -0,0 +1,144 @@
+import { defineComponent as h, useTemplateRef as m, shallowRef as O, ref as v, provide as R, onMounted as w, onUnmounted as d, openBlock as b, createElementBlock as x, createElementVNode as y, renderSlot as C, inject as N, computed as B, watch as k } from "vue";
+import { createGameEngine as z } from "@skewedaspect/sage";
+const E = /* @__PURE__ */ Symbol("sage-engine"), D = { class: "sage-overlay" }, G = /* @__PURE__ */ h({
+  __name: "sageCanvas",
+  props: {
+    entityDefinitions: { default: () => [] },
+    options: { default: () => ({}) },
+    engine: {}
+  },
+  emits: ["engine-ready", "engine-error"],
+  setup(e, { emit: n }) {
+    const r = e, t = n, s = m("containerRef"), a = m("canvasRef"), o = O(null), i = v(!0), u = v(null);
+    let p = !1, c = null;
+    return R(E, o), w(async () => {
+      let f = !1;
+      if (d(() => {
+        f = !0;
+      }), !!a.value)
+        try {
+          let l;
+          if (r.engine ? (l = r.engine, p = !0) : l = await z(a.value, r.entityDefinitions, r.options), f)
+            return;
+          o.value = l, s.value && (c = new ResizeObserver(() => {
+            l.renderEngine.resize();
+          }), c.observe(s.value)), t("engine-ready", l), i.value = !1;
+        } catch (l) {
+          if (f)
+            return;
+          u.value = l, t("engine-error", l), i.value = !1;
+        }
+    }), d(async () => {
+      c && (c.disconnect(), c = null), !p && o.value && (await o.value.stop(), o.value.renderEngine.dispose());
+    }), (f, l) => (b(), x("div", {
+      ref_key: "containerRef",
+      ref: s,
+      class: "sage-container"
+    }, [
+      y("canvas", {
+        ref_key: "canvasRef",
+        ref: a,
+        class: "sage-canvas"
+      }, null, 512),
+      y("div", D, [
+        C(f.$slots, "default", {
+          loading: i.value,
+          error: u.value,
+          engine: o.value
+        }, void 0, !0)
+      ])
+    ], 512));
+  }
+}), P = (e, n) => {
+  const r = e.__vccOpts || e;
+  for (const [t, s] of n)
+    r[t] = s;
+  return r;
+}, T = /* @__PURE__ */ P(G, [["__scopeId", "data-v-7932fefe"]]);
+function g() {
+  const e = N(E);
+  if (!e)
+    throw new Error("useSageEngine() must be used inside a <SageCanvas> component.");
+  return {
+    engine: e,
+    eventBus: B(() => e.value?.eventBus ?? null)
+  };
+}
+function S(e, n) {
+  const { engine: r } = g();
+  let t = null;
+  k(r, (s) => {
+    t && (t(), t = null), s && (t = s.eventBus.subscribePattern(
+      e,
+      n
+    ));
+  }, { immediate: !0 }), d(() => {
+    t && (t(), t = null);
+  });
+}
+function $(e) {
+  const n = v(0);
+  return S(`action:${e}`, (r) => {
+    n.value = r.payload.value;
+  }), n;
+}
+function j(e, n) {
+  const { engine: r } = g(), t = () => {
+    const a = r.value?.managers.entityManager.getEntity(e);
+    if (a)
+      return n ? a.state[n] : a.state;
+  }, s = v(t());
+  return S("entity:state-changed", (a) => {
+    a.payload.entityId === e && (s.value = t());
+  }), s;
+}
+const _ = () => {
+}, A = {
+  get ready() {
+    return !1;
+  },
+  reset() {
+  }
+};
+function K() {
+  const { engine: e } = g(), n = [];
+  d(() => {
+    for (const a of n)
+      a();
+    n.length = 0;
+  });
+  function r(a, o) {
+    if (!e.value)
+      return _;
+    const i = e.value.timer.delay(a, o);
+    return n.push(i), () => {
+      i();
+      const u = n.indexOf(i);
+      u >= 0 && n.splice(u, 1);
+    };
+  }
+  function t(a, o) {
+    if (!e.value)
+      return _;
+    const i = e.value.timer.interval(a, o);
+    return n.push(i), () => {
+      i();
+      const u = n.indexOf(i);
+      u >= 0 && n.splice(u, 1);
+    };
+  }
+  function s(a) {
+    return e.value ? e.value.timer.cooldown(a) : A;
+  }
+  return { delay: r, interval: t, cooldown: s };
+}
+export {
+  E as SAGE_ENGINE_KEY,
+  T as SageCanvas,
+  $ as useSageAction,
+  g as useSageEngine,
+  S as useSageEvent,
+  j as useSageState,
+  K as useSageTimer
+};
+//# sourceMappingURL=sage-vue.js.map

package/dist/sage-vue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sage-vue.js","sources":["../src/symbols.ts","../src/sageCanvas.vue","../src/useSageEngine.ts","../src/useSageEvent.ts","../src/useSageAction.ts","../src/useSageState.ts","../src/useSageTimer.ts"],"sourcesContent":["//----------------------------------------------------------------------------------------------------------------------\n// Injection Key Symbols\n//----------------------------------------------------------------------------------------------------------------------\n\nimport type { InjectionKey, ShallowRef } from 'vue';\nimport type { GameEngine } from '@skewedaspect/sage';\n\n//----------------------------------------------------------------------------------------------------------------------\n\nexport const SAGE_ENGINE_KEY : InjectionKey<ShallowRef<GameEngine | null>> = Symbol('sage-engine');\n\n//----------------------------------------------------------------------------------------------------------------------\n","<!----------------------------------------------------------------------------------------------------------------------\n  - SageCanvas - Vue wrapper component for the SAGE game engine\n  ----------------------------------------------------------------------------------------------------------------------->\n\n<template>\n    <div ref=\"containerRef\" class=\"sage-container\">\n        <canvas ref=\"canvasRef\" class=\"sage-canvas\"></canvas>\n        <div class=\"sage-overlay\">\n            <slot :loading=\"loading\" :error=\"error\" :engine=\"engineRef\"></slot>\n        </div>\n    </div>\n</template>\n\n<!--------------------------------------------------------------------------------------------------------------------->\n\n<style scoped>\n    .sage-container {\n        position: relative;\n        width: 100%;\n        height: 100%;\n    }\n\n    .sage-canvas {\n        display: block;\n        width: 100%;\n        height: 100%;\n    }\n\n    .sage-overlay {\n        position: absolute;\n        top: 0;\n        left: 0;\n        width: 100%;\n        height: 100%;\n        pointer-events: none;\n    }\n\n    .sage-overlay :deep(*) {\n        pointer-events: auto;\n    }\n</style>\n\n<!--------------------------------------------------------------------------------------------------------------------->\n\n<script setup lang=\"ts\">\n    import { ref, shallowRef, provide, onMounted, onUnmounted, useTemplateRef } from 'vue';\n    import { createGameEngine } from '@skewedaspect/sage';\n    import type { GameEngine, GameEntityDefinition, SageOptions } from '@skewedaspect/sage';\n    import { SAGE_ENGINE_KEY } from './symbols.ts';\n\n    //------------------------------------------------------------------------------------------------------------------\n    // Props & Emits\n    //------------------------------------------------------------------------------------------------------------------\n\n    const props = withDefaults(defineProps<{\n        entityDefinitions ?: GameEntityDefinition[];\n        options ?: SageOptions;\n        engine ?: GameEngine;\n    }>(), {\n        entityDefinitions: () => [],\n        options: () => ({}),\n    });\n\n    const emit = defineEmits<{\n        'engine-ready': [engine : GameEngine];\n        'engine-error': [error : unknown];\n    }>();\n\n    //------------------------------------------------------------------------------------------------------------------\n    // State\n    //------------------------------------------------------------------------------------------------------------------\n\n    const containerRef = useTemplateRef<HTMLDivElement>('containerRef');\n    const canvasRef = useTemplateRef<HTMLCanvasElement>('canvasRef');\n    const engineRef = shallowRef<GameEngine | null>(null);\n    const loading = ref(true);\n    const error = ref<unknown>(null);\n    let controlled = false;\n    let resizeObserver : ResizeObserver | null = null;\n\n    // Provide the engine ref synchronously so child composables can inject it\n    provide(SAGE_ENGINE_KEY, engineRef);\n\n    //------------------------------------------------------------------------------------------------------------------\n    // Lifecycle\n    //------------------------------------------------------------------------------------------------------------------\n\n    onMounted(async() =>\n    {\n        let disposed = false;\n\n        onUnmounted(() =>\n        {\n            disposed = true;\n        });\n\n        if(!canvasRef.value)\n        {\n            return;\n        }\n\n        try\n        {\n            let engine : GameEngine;\n\n            if(props.engine)\n            {\n                engine = props.engine;\n                controlled = true;\n            }\n            else\n            {\n                engine = await createGameEngine(canvasRef.value, props.entityDefinitions, props.options);\n            }\n\n            if(disposed) { return; }\n\n            engineRef.value = engine;\n\n            // Set up resize observer on the container\n            if(containerRef.value)\n            {\n                resizeObserver = new ResizeObserver(() =>\n                {\n                    engine.renderEngine.resize();\n                });\n                resizeObserver.observe(containerRef.value);\n            }\n\n            emit('engine-ready', engine);\n            loading.value = false;\n        }\n        catch(err)\n        {\n            if(disposed) { return; }\n\n            error.value = err;\n            emit('engine-error', err);\n            loading.value = false;\n        }\n    });\n\n    onUnmounted(async() =>\n    {\n        if(resizeObserver)\n        {\n            resizeObserver.disconnect();\n            resizeObserver = null;\n        }\n\n        if(!controlled && engineRef.value)\n        {\n            await engineRef.value.stop();\n            engineRef.value.renderEngine.dispose();\n        }\n    });\n</script>\n\n<!--------------------------------------------------------------------------------------------------------------------->\n","//----------------------------------------------------------------------------------------------------------------------\n// useSageEngine Composable\n//----------------------------------------------------------------------------------------------------------------------\n\nimport { type ComputedRef, type ShallowRef, computed, inject } from 'vue';\nimport type { GameEngine, GameEventBus } from '@skewedaspect/sage';\nimport { SAGE_ENGINE_KEY } from './symbols.ts';\n\n//----------------------------------------------------------------------------------------------------------------------\n\ninterface SageEngineContext\n{\n    engine : ShallowRef<GameEngine | null>;\n    eventBus : ComputedRef<GameEventBus | null>;\n}\n\nexport function useSageEngine() : SageEngineContext\n{\n    const engine = inject(SAGE_ENGINE_KEY);\n    if(!engine)\n    {\n        throw new Error('useSageEngine() must be used inside a <SageCanvas> component.');\n    }\n\n    return {\n        engine,\n        eventBus: computed(() => engine.value?.eventBus ?? null),\n    };\n}\n\n//----------------------------------------------------------------------------------------------------------------------\n","//----------------------------------------------------------------------------------------------------------------------\n// useSageEvent Composable\n//----------------------------------------------------------------------------------------------------------------------\n\nimport { onUnmounted, watch } from 'vue';\nimport type { GameEvent, Unsubscribe, WildcardEventCallback, WildcardPattern } from '@skewedaspect/sage';\nimport { useSageEngine } from './useSageEngine.ts';\n\n//----------------------------------------------------------------------------------------------------------------------\n\ntype EventHandler = (event : GameEvent) => void | Promise<void>;\n\nexport function useSageEvent(pattern : string | RegExp, handler : EventHandler) : void\n{\n    const { engine } = useSageEngine();\n    let unsub : Unsubscribe | null = null;\n\n    watch(engine, (eng) =>\n    {\n        if(unsub)\n        {\n            unsub();\n            unsub = null;\n        }\n\n        if(eng)\n        {\n            unsub = eng.eventBus.subscribePattern(\n                pattern as WildcardPattern | RegExp,\n                handler as WildcardEventCallback\n            );\n        }\n    }, { immediate: true });\n\n    onUnmounted(() =>\n    {\n        if(unsub)\n        {\n            unsub();\n            unsub = null;\n        }\n    });\n}\n\n//----------------------------------------------------------------------------------------------------------------------\n","//----------------------------------------------------------------------------------------------------------------------\n// useSageAction Composable\n//----------------------------------------------------------------------------------------------------------------------\n\nimport { type Ref, ref } from 'vue';\nimport { useSageEvent } from './useSageEvent.ts';\n\n//----------------------------------------------------------------------------------------------------------------------\n\nexport function useSageAction(actionName : string) : Ref<boolean | number>\n{\n    const value = ref<boolean | number>(0);\n\n    useSageEvent(`action:${ actionName }`, (event) =>\n    {\n        value.value = (event.payload as { value : boolean | number }).value;\n    });\n\n    return value;\n}\n\n//----------------------------------------------------------------------------------------------------------------------\n","//----------------------------------------------------------------------------------------------------------------------\n// useSageState Composable\n//----------------------------------------------------------------------------------------------------------------------\n\nimport { type Ref, ref } from 'vue';\nimport type { EntityStateChangedPayload } from '@skewedaspect/sage';\nimport { useSageEngine } from './useSageEngine.ts';\nimport { useSageEvent } from './useSageEvent.ts';\n\n//----------------------------------------------------------------------------------------------------------------------\n\n/**\n * Returns a reactive ref synced to an entity's state. If `key` is provided, tracks only that property; otherwise\n * tracks the entire state object.\n */\nexport function useSageState<T = unknown>(entityId : string, key ?: string) : Ref<T>\n{\n    const { engine } = useSageEngine();\n\n    // Read initial state from the entity (if it exists yet)\n    const readState = () : T =>\n    {\n        const entity = engine.value?.managers.entityManager.getEntity(entityId);\n        if(!entity)\n        {\n            return undefined as T;\n        }\n\n        if(key)\n        {\n            return (entity.state as Record<string, unknown>)[key] as T;\n        }\n\n        return entity.state as T;\n    };\n\n    const state = ref<T>(readState()) as Ref<T>;\n\n    useSageEvent('entity:state-changed', (event) =>\n    {\n        const payload = event.payload as EntityStateChangedPayload;\n        if(payload.entityId !== entityId)\n        {\n            return;\n        }\n\n        // Re-read from the entity to get the authoritative value\n        state.value = readState();\n    });\n\n    return state;\n}\n\n//----------------------------------------------------------------------------------------------------------------------\n","//----------------------------------------------------------------------------------------------------------------------\n// useSageTimer Composable\n//----------------------------------------------------------------------------------------------------------------------\n\nimport { onUnmounted } from 'vue';\nimport type { CooldownHandle } from '@skewedaspect/sage';\nimport { useSageEngine } from './useSageEngine.ts';\n\n//----------------------------------------------------------------------------------------------------------------------\n\ninterface SageTimerComposable\n{\n    delay : (ms : number, callback : () => void) => () => void;\n    interval : (ms : number, callback : () => void) => () => void;\n    cooldown : (ms : number) => CooldownHandle;\n}\n\n//----------------------------------------------------------------------------------------------------------------------\n\n// eslint-disable-next-line @typescript-eslint/no-empty-function\nconst NOOP = () : void => {};\n\nconst NOOP_COOLDOWN : CooldownHandle = {\n    get ready() : boolean { return false; },\n    reset() : void { /* no-op */ },\n};\n\n//----------------------------------------------------------------------------------------------------------------------\n\n/**\n * Returns pause-aware timer functions (delay, interval, cooldown) from the game engine. All active timers are\n * automatically cancelled when the component unmounts.\n */\nexport function useSageTimer() : SageTimerComposable\n{\n    const { engine } = useSageEngine();\n    const cancellers : (() => void)[] = [];\n\n    onUnmounted(() =>\n    {\n        for(const cancel of cancellers)\n        {\n            cancel();\n        }\n\n        cancellers.length = 0;\n    });\n\n    function delay(ms : number, callback : () => void) : () => void\n    {\n        if(!engine.value)\n        {\n            return NOOP;\n        }\n\n        const cancel = engine.value.timer.delay(ms, callback);\n        cancellers.push(cancel);\n\n        return () =>\n        {\n            cancel();\n            const idx = cancellers.indexOf(cancel);\n            if(idx >= 0)\n            {\n                cancellers.splice(idx, 1);\n            }\n        };\n    }\n\n    function interval(ms : number, callback : () => void) : () => void\n    {\n        if(!engine.value)\n        {\n            return NOOP;\n        }\n\n        const cancel = engine.value.timer.interval(ms, callback);\n        cancellers.push(cancel);\n\n        return () =>\n        {\n            cancel();\n            const idx = cancellers.indexOf(cancel);\n            if(idx >= 0)\n            {\n                cancellers.splice(idx, 1);\n            }\n        };\n    }\n\n    function cooldown(ms : number) : CooldownHandle\n    {\n        if(!engine.value)\n        {\n            return NOOP_COOLDOWN;\n        }\n\n        const handle = engine.value.timer.cooldown(ms);\n\n        // There's no cancel for cooldowns, but we don't need to track them — they're passive pollable objects\n        return handle;\n    }\n\n    return { delay, interval, cooldown };\n}\n\n//----------------------------------------------------------------------------------------------------------------------\n"],"names":["SAGE_ENGINE_KEY","props","__props","emit","__emit","containerRef","useTemplateRef","canvasRef","engineRef","shallowRef","loading","ref","error","controlled","resizeObserver","provide","onMounted","disposed","onUnmounted","engine","createGameEngine","err","_createElementBlock","_createElementVNode","_hoisted_1","_renderSlot","_ctx","useSageEngine","inject","computed","useSageEvent","pattern","handler","unsub","watch","eng","useSageAction","actionName","value","event","useSageState","entityId","key","readState","entity","state","NOOP","NOOP_COOLDOWN","useSageTimer","cancellers","cancel","delay","ms","callback","idx","interval","cooldown"],"mappings":"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"}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@skewedaspect/sage-vue",
+  "version": "0.8.0",
+  "type": "module",
+  "main": "dist/sage-vue.es.js",
+  "module": "dist/sage-vue.es.js",
+  "types": "dist/index.d.ts",
+  "author": "Christopher S. Case<chris.case@g33xnexus.com>",
+  "license": "MIT",
+  "description": "Vue 3 integration components for the SAGE game engine.",
+  "scripts": {
+    "build": "vite build"
+  },
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "@skewedaspect/sage": "*",
+    "vue": "^3.5.0"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-vue": "^6.0.3",
+    "vite": "^7.3.1",
+    "vite-plugin-dts": "^4.5.3",
+    "typescript": "^5.8.3",
+    "vue": "^3.5.27"
+  }
+}