@hi-ashleyj/llama 0.13.2 → 0.14.0

package/dist/Game.svelte

@@ -1,137 +1,162 @@
-<script>import { writable } from "svelte/store";
-import { onMount } from "svelte";
-import { setupGame } from "./core-contexts.js";
-import { Timing } from "./controllers/motions.js";
-import { Keyboard } from "./controllers/keyboard.js";
-import { Mouse } from "./controllers/mouse.js";
-import { getSetupAudio } from "./audio/context.js";
-import { decodeAllBuffers } from "./resources/audio.js";
-const raise = (err) => {
-  throw new Error(err);
-};
-export let width = 1920;
-export let height = 1080;
-export let background = "#000000";
-const widthStore = writable(1920);
-const heightStore = writable(1080);
-const backgroundStore = writable("#000000");
-$: {
-  $widthStore = width;
-}
-$: {
-  $heightStore = height;
-}
-$: {
-  $backgroundStore = background;
-}
-const layerDrawables = /* @__PURE__ */ new Set();
-const layerAssignments = /* @__PURE__ */ new Map();
-const draw = function() {
-  for (let layer of layerDrawables) {
-    if (layer.isStatic())
-      continue;
-    layer.draw();
-  }
-};
-const assign = function(ctx, obj) {
-  layerDrawables.add(obj);
-  layerAssignments.set(obj.name, ctx);
-  return () => {
-    layerDrawables.delete(obj);
-    layerAssignments.delete(obj.name);
-  };
-};
-const timing = new Timing();
-const keyboard = new Keyboard();
-const mouse = new Mouse();
-const frameEvents = /* @__PURE__ */ new Set();
-const frameBeforeEvents = /* @__PURE__ */ new Set();
-const frameAfterEvents = /* @__PURE__ */ new Set();
-export const context = {
-  width: widthStore,
-  height: heightStore,
-  background: backgroundStore,
-  getLayerByName: (name) => layerAssignments.get(name) ?? null,
-  assign,
-  createTimer: timing.createTimer.bind(timing),
-  createBurst: timing.createBurst.bind(timing),
-  onKeyboardEvent: keyboard.on.bind(keyboard),
-  isKeyboardPressed: keyboard.isPressed.bind(keyboard),
-  getKeyboardStore: keyboard.getStore.bind(keyboard),
-  onMouseEvent: mouse.on.bind(mouse),
-  isMousePressed: mouse.isPressed.bind(mouse),
-  getMousePosition: mouse.getPosition.bind(mouse),
-  getMouseStore: mouse.getStore.bind(mouse),
-  onFrame: (callback) => {
-    frameEvents.add(callback);
-    return () => frameEvents.delete(callback);
-  },
-  onBeforeFrame: (callback) => {
-    frameBeforeEvents.add(callback);
-    return () => frameBeforeEvents.delete(callback);
-  },
-  onAfterFrame: (callback) => {
-    frameAfterEvents.add(callback);
-    return () => frameAfterEvents.delete(callback);
-  },
-  defaultTextFontFace: writable(null),
-  getAudioContext: () => audio ? audio : raise("There Is No AudioContext")
-};
-setupGame(context);
-let last = -1;
-const loop = function(time) {
-  if (last < 0)
-    last = time;
-  let delta = time - last;
-  if (delta > 1e3) {
-    requestAnimationFrame(loop);
-    return last = time;
-  }
-  frameBeforeEvents.forEach((callback) => callback({ delta, time }));
-  timing.update(delta);
-  frameEvents.forEach((callback) => callback({ delta, time }));
-  draw();
-  frameAfterEvents.forEach((callback) => callback({ delta, time }));
-  requestAnimationFrame(loop);
-  last = time;
-};
-let audio = null;
-getSetupAudio((node) => {
-  if (!audio)
-    throw new Error("Audio Is Not Yet Created!");
-  node.connect(audio.destination);
-  return () => audio && node.disconnect(audio.destination);
-});
-onMount(() => {
-  audio = new AudioContext();
-  decodeAllBuffers(audio);
-  requestAnimationFrame(loop);
-  keyboard.start();
-  mouse.start();
-});
-let wiw = 0;
-let wih = 0;
-$: {
-  mouse.changeWindowDimensions(wiw, wih);
-}
-$: {
-  mouse.setHeight(height);
-}
-$: {
-  mouse.setWidth(width);
-}
-const resumeAudioContext = () => {
-  if (audio?.state === "suspended") {
-    audio?.resume();
-  }
-};
+<script lang="ts">
+    import { writable } from "svelte/store";
+    import { onMount } from "svelte";
+    import { setupGame, type GameContext, type LayerContext, type LayerDrawable } from "./core-contexts.js";
+    import { Timing } from "./controllers/motions.js";
+    import { Keyboard } from "./controllers/keyboard.js";
+    import type { Writable } from "svelte/store";
+    import { Mouse } from "./controllers/mouse.js";
+    import { getSetupAudio } from "./audio/context.js";
+    import { decodeAllBuffers } from "./resources/audio.js";
+
+    const raise = (err: string) => {
+        throw new Error(err);
+    }
+
+    interface Props {
+        width?: number;
+        height?: number;
+        background?: string;
+        children?: import('svelte').Snippet;
+    }
+
+    let {
+        width = 1920,
+        height = 1080,
+        background = "#000000",
+        children
+    }: Props = $props();
+
+    const widthStore: Writable<number> = writable(1920);
+    const heightStore: Writable<number> = writable(1080);
+    const backgroundStore: Writable<string> = writable("#000000");
+
+    $effect(() => { $widthStore = width })
+    $effect(() => { $heightStore = height })
+    $effect(() => { $backgroundStore = background })
+
+    const layerDrawables = new Set<LayerDrawable>();
+    const layerAssignments = new Map<string, LayerContext>();
+
+    const draw = function() {
+        for (let layer of layerDrawables) {
+            if (layer.isStatic()) continue;
+            layer.draw();
+        }
+    };
+
+    const assign = function(ctx: LayerContext, obj: LayerDrawable) {
+        layerDrawables.add(obj);
+        layerAssignments.set(obj.name, ctx);
+        return () => { 
+            layerDrawables.delete(obj);
+            layerAssignments.delete(obj.name); 
+        };
+    };
+
+    const timing = new Timing();
+    const keyboard = new Keyboard();
+    const mouse = new Mouse();
+
+    const frameEvents: Set<(info: { delta: number, time: number }) => any | void> = new Set();
+    const frameBeforeEvents: Set<(info: { delta: number, time: number }) => any | void> = new Set();
+    const frameAfterEvents: Set<(info: { delta: number, time: number }) => any | void> = new Set();
+
+    export const context: GameContext = {
+        width: widthStore,
+        height: heightStore,
+        background: backgroundStore,
+        getLayerByName: (name) => layerAssignments.get(name) ?? null,
+        assign,
+        createTimer: timing.createTimer.bind(timing),
+        createBurst: timing.createBurst.bind(timing),
+        onKeyboardEvent: keyboard.on.bind(keyboard),
+        isKeyboardPressed: keyboard.isPressed.bind(keyboard),
+        getKeyboardStore: keyboard.getStore.bind(keyboard),
+        onMouseEvent: mouse.on.bind(mouse),
+        isMousePressed: mouse.isPressed.bind(mouse),
+        getMousePosition: mouse.getPosition.bind(mouse),
+        getMouseStore: mouse.getStore.bind(mouse),
+        onFrame: (callback) => {
+            frameEvents.add(callback);
+            return () => frameEvents.delete(callback);
+        },
+        onBeforeFrame: (callback) => {
+            frameBeforeEvents.add(callback);
+            return () => frameBeforeEvents.delete(callback);
+        },
+        onAfterFrame: (callback) => {
+            frameAfterEvents.add(callback);
+            return () => frameAfterEvents.delete(callback);
+        },
+        defaultTextFontFace: writable(null),
+        getAudioContext: () => audio ? audio : raise("There Is No AudioContext"),
+    }
+
+    setupGame(context);
+    let last = -1;
+
+    const loop = function(time: DOMHighResTimeStamp) {
+        if (last < 0) last = time;
+
+        let delta = (time - last);
+
+        if (delta > 1000) {
+            requestAnimationFrame(loop);
+            return last = time;
+        }
+
+        // TODO: NEW TIMEOUT LOGIC
+
+        frameBeforeEvents.forEach((callback) => callback({ delta, time }));
+
+        timing.update(delta);
+
+        frameEvents.forEach((callback) => callback({ delta, time }));
+
+        draw();
+
+        frameAfterEvents.forEach((callback) => callback({ delta, time }));
+
+        requestAnimationFrame(loop);
+        last = time;
+    };
+
+    let audio: AudioContext | null = null;
+    getSetupAudio((node) => {
+        if (!audio) throw new Error("Audio Is Not Yet Created!")
+        node.connect(audio.destination);
+        return () => audio && node.disconnect(audio.destination);
+    })
+
+    onMount(() => {
+        audio = new AudioContext();
+        decodeAllBuffers(audio);
+        requestAnimationFrame(loop);
+        keyboard.start();
+        mouse.start();
+    });
+
+    let wiw = $state(0);
+    let wih = $state(0);
+
+    $effect(() => mouse.changeWindowDimensions(wiw, wih));
+    $effect(() => mouse.setHeight(height));
+    $effect(() => mouse.setWidth(width));
+
+    const resumeAudioContext = () => {
+        if (audio?.state === "suspended") {
+            audio?.resume();
+        }
+    }
+
 </script>
 
 <div class="game" style:background-color={background}>
-    <slot />
+    {@render children?.()}
 </div>
 
-<svelte:window bind:innerHeight={wih} bind:innerWidth={wiw} on:click={resumeAudioContext} on:keydown={resumeAudioContext}></svelte:window>
+<svelte:window bind:innerHeight={wih} bind:innerWidth={wiw} onclick={resumeAudioContext} onkeydown={resumeAudioContext}></svelte:window>
 
 <style>
     .game {

package/dist/Game.svelte.d.ts

@@ -1,23 +1,12 @@
-import { SvelteComponent } from "svelte";
 import { type GameContext } from "./core-contexts.js";
-declare const __propDef: {
-    props: {
-        width?: number | undefined;
-        height?: number | undefined;
-        background?: string | undefined;
-        context?: GameContext | undefined;
-    };
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {
-        default: {};
-    };
-};
-export type GameProps = typeof __propDef.props;
-export type GameEvents = typeof __propDef.events;
-export type GameSlots = typeof __propDef.slots;
-export default class Game extends SvelteComponent<GameProps, GameEvents, GameSlots> {
-    get context(): GameContext;
+interface Props {
+    width?: number;
+    height?: number;
+    background?: string;
+    children?: import('svelte').Snippet;
 }
-export {};
+declare const Game: import("svelte").Component<Props, {
+    context: GameContext;
+}, "">;
+type Game = ReturnType<typeof Game>;
+export default Game;

package/dist/Layer.svelte

@@ -1,52 +1,67 @@
-<script>import { setupLayer, getGame } from "./core-contexts.js";
-import { onMount } from "svelte";
-export let zIndex = 0;
-export let staticMode = false;
-export let scaleMode = "pixelated";
-let shouldRenderNextFrame = true;
-let canvas;
-$:
-  ctx = typeof canvas !== "undefined" ? canvas.getContext("2d") : null;
-let targets = /* @__PURE__ */ new Set();
-const { width, height } = getGame();
-const draw = () => {
-  if (ctx === null)
-    return;
-  ctx.clearRect(0, 0, $width, $height);
-  ctx.imageSmoothingEnabled = scaleMode === "smooth";
-  targets.forEach((f) => f.draw({ width: $width, height: $height, ctx }));
-};
-let register = setupLayer({
-  assign: (ctx2) => {
-    targets.add(ctx2);
-    return () => {
-      targets.delete(ctx2);
-    };
-  },
-  requestFrame: () => {
-    if (!staticMode)
-      return;
-    shouldRenderNextFrame = true;
-  }
-});
-export let name;
-onMount(() => {
-  return register({
-    draw,
-    isStatic: () => {
-      if (shouldRenderNextFrame) {
-        shouldRenderNextFrame = false;
-        draw();
-      }
-      return staticMode;
-    },
-    name
-  });
-});
+<script lang="ts">
+
+    import { setupLayer, getGame } from "./core-contexts.js";
+    import type { DrawFunction } from "./drawable.js";
+    import { onMount } from "svelte";
+
+    let shouldRenderNextFrame = true;
+
+    let canvas: HTMLCanvasElement | undefined = $state();
+    let ctx = $derived((typeof canvas !== "undefined") ? canvas.getContext("2d") : null);
+
+    let targets = new Set<{ draw: DrawFunction<null> }>();
+    
+    const { width, height } = getGame();
+
+    const draw = () => {
+        if (ctx === null) return;
+        ctx.clearRect(0, 0, $width, $height);
+        ctx.imageSmoothingEnabled = scaleMode === "smooth";
+        targets.forEach(f => f.draw({ width: $width, height: $height, ctx: ctx! }));
+    }
+
+    let register = setupLayer({
+        assign: (ctx) => {
+            targets.add(ctx);
+            return () => { targets.delete(ctx) }
+        },
+        requestFrame: () => {
+            if (!staticMode) return;
+            shouldRenderNextFrame = true;
+        }
+    });
+
+    interface Props {
+        zIndex?: number;
+        staticMode?: boolean;
+        scaleMode?: "pixelated" | "smooth";
+        name: string;
+        children?: import('svelte').Snippet;
+    }
+
+    let {
+        zIndex = 0,
+        staticMode = false,
+        scaleMode = "pixelated",
+        name,
+        children
+    }: Props = $props();
+
+    onMount(() => {
+        return register({ 
+            draw, 
+            isStatic: () => { 
+                if (shouldRenderNextFrame) { shouldRenderNextFrame = false; draw(); } 
+                return staticMode; 
+            },
+            name: name,
+        });
+    })
+
 </script>
 
 <canvas width={$width} height={$height} bind:this={canvas} style:z-index={zIndex}></canvas>
-<slot />
+{@render children?.()}
 
 <style>
     canvas {

package/dist/Layer.svelte.d.ts

@@ -1,21 +1,10 @@
-import { SvelteComponent } from "svelte";
-declare const __propDef: {
-    props: {
-        zIndex?: number | undefined;
-        staticMode?: boolean | undefined;
-        scaleMode?: "pixelated" | "smooth" | undefined;
-        name: string;
-    };
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {
-        default: {};
-    };
-};
-export type LayerProps = typeof __propDef.props;
-export type LayerEvents = typeof __propDef.events;
-export type LayerSlots = typeof __propDef.slots;
-export default class Layer extends SvelteComponent<LayerProps, LayerEvents, LayerSlots> {
+interface Props {
+    zIndex?: number;
+    staticMode?: boolean;
+    scaleMode?: "pixelated" | "smooth";
+    name: string;
+    children?: import('svelte').Snippet;
 }
-export {};
+declare const Layer: import("svelte").Component<Props, {}, "">;
+type Layer = ReturnType<typeof Layer>;
+export default Layer;

package/dist/audio/AudioCompressor.svelte

@@ -1,46 +1,72 @@
-<script>import { getAudioContext, getConnector } from "./context.js";
-import { onMount } from "svelte";
-const audioContext = getAudioContext();
-export let preGain = 1;
-export let postGain = 1;
-export let attack = 10;
-export let threshold = -6;
-export let blend = 3;
-export let ratio = 2;
-export let release = 150;
-let output;
-let input;
-let process;
-$: {
-  if (output) {
-    output.gain.setTargetAtTime(postGain, audioCTX.currentTime, 4e-3);
-  }
-}
-$: {
-  if (input) {
-    input.gain.setTargetAtTime(preGain, audioCTX.currentTime, 4e-3);
-  }
-}
-$: {
-  if (process) {
-    process.attack.setTargetAtTime(attack / 1e3, audioCTX.currentTime, 4e-3);
-    process.threshold.setTargetAtTime(threshold, audioCTX.currentTime, 4e-3);
-    process.knee.setTargetAtTime(Math.min(threshold + blend, 0), audioCTX.currentTime, 4e-3);
-    process.ratio.setTargetAtTime(ratio, audioCTX.currentTime, 4e-3);
-    process.release.setTargetAtTime(release / 1e3, audioCTX.currentTime, 4e-3);
-  }
-}
-const connect = getConnector((node) => {
-  node.connect(output);
-  return () => node.disconnect(output);
-});
-onMount(() => {
-  const audioCTX2 = audioContext();
-  output = audioCTX2.createGain();
-  input = audioCTX2.createGain();
-  process = audioCTX2.createDynamicsCompressor();
-  return connect(output);
-});
+<script lang="ts">
+
+    import { getAudioContext, getConnector } from "./context.js";
+    import { onMount } from "svelte";
+    const audioContext = getAudioContext();
+
+    type Millisecond = number;
+    type Decibel = number;
+    interface Props {
+        preGain?: number;
+        postGain?: number;
+        attack?: Millisecond;
+        threshold?: Decibel;
+        blend?: Decibel;
+        ratio?: number;
+        release?: Millisecond;
+        children?: import('svelte').Snippet;
+    }
+
+    let {
+        preGain = 1,
+        postGain = 1,
+        attack = 10,
+        threshold = -6,
+        blend = 3,
+        ratio = 2,
+        release = 150,
+        children
+    }: Props = $props();
+
+    let output: GainNode = $state();
+    let input: GainNode = $state();
+    let process: DynamicsCompressorNode = $state();
+
+    $effect(() => {
+
+        if (output) {
+            output.gain.setTargetAtTime(postGain, audioCTX.currentTime, 0.004);
+        }
+    })
+
+    $effect(() => {
+        if (input) {
+            input.gain.setTargetAtTime(preGain, audioCTX.currentTime, 0.004);
+        }
+    });
+    $effect(() => {
+        if (process) {
+            process.attack.setTargetAtTime(attack / 1000, audioCTX.currentTime, 0.004);
+            process.threshold.setTargetAtTime(threshold, audioCTX.currentTime, 0.004);
+            process.knee.setTargetAtTime(Math.min(threshold + blend, 0), audioCTX.currentTime, 0.004);
+            process.ratio.setTargetAtTime(ratio, audioCTX.currentTime, 0.004);
+            process.release.setTargetAtTime(release / 1000, audioCTX.currentTime, 0.004);
+        }
+    });
+
+    const connect = getConnector((node) => {
+        node.connect(output);
+        return () => node.disconnect(output);
+    });
+
+    onMount(() => {
+        const audioCTX = audioContext();
+        output = audioCTX.createGain();
+        input = audioCTX.createGain();
+        process = audioCTX.createDynamicsCompressor();
+        return connect(output);
+    })
+
 </script>
 
-<slot />
+{@render children?.()}

package/dist/audio/AudioCompressor.svelte.d.ts

@@ -1,24 +1,15 @@
-import { SvelteComponent } from "svelte";
-declare const __propDef: {
-    props: {
-        preGain?: number | undefined;
-        postGain?: number | undefined;
-        attack?: number | undefined;
-        threshold?: number | undefined;
-        blend?: number | undefined;
-        ratio?: number | undefined;
-        release?: number | undefined;
-    };
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {
-        default: {};
-    };
-};
-export type AudioCompressorProps = typeof __propDef.props;
-export type AudioCompressorEvents = typeof __propDef.events;
-export type AudioCompressorSlots = typeof __propDef.slots;
-export default class AudioCompressor extends SvelteComponent<AudioCompressorProps, AudioCompressorEvents, AudioCompressorSlots> {
+type Millisecond = number;
+type Decibel = number;
+interface Props {
+    preGain?: number;
+    postGain?: number;
+    attack?: Millisecond;
+    threshold?: Decibel;
+    blend?: Decibel;
+    ratio?: number;
+    release?: Millisecond;
+    children?: import('svelte').Snippet;
 }
-export {};
+declare const AudioCompressor: import("svelte").Component<Props, {}, "">;
+type AudioCompressor = ReturnType<typeof AudioCompressor>;
+export default AudioCompressor;