@hi-ashleyj/llama 0.13.1 → 0.14.0

package/dist/drawables/Tiled.svelte.d.ts

@@ -1,22 +1,12 @@
-import { SvelteComponent } from "svelte";
 import type { TileSet } from "../resources/tileset.js";
-declare const __propDef: {
-    props: {
-        shiftX: number;
-        shiftY: number;
-        drawSize: number;
-        tileSet: TileSet;
-        alias: Record<string, [number, number]>;
-        map: string[];
-    };
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-export type TiledProps = typeof __propDef.props;
-export type TiledEvents = typeof __propDef.events;
-export type TiledSlots = typeof __propDef.slots;
-export default class Tiled extends SvelteComponent<TiledProps, TiledEvents, TiledSlots> {
+interface Props {
+    shiftX: number;
+    shiftY: number;
+    drawSize: number;
+    tileSet: TileSet;
+    alias: Record<string, [number, number]>;
+    map: string[];
 }
-export {};
+declare const Tiled: import("svelte").Component<Props, {}, "">;
+type Tiled = ReturnType<typeof Tiled>;
+export default Tiled;

package/dist/extras/DefaultFontFace.svelte

@@ -1,18 +1,36 @@
-<script>import { getGame } from "../core-contexts.js";
-import { onMount, createEventDispatcher } from "svelte";
-const { defaultTextFontFace } = getGame();
-const dispatch = createEventDispatcher();
-export let font;
-export let url = null;
-onMount(() => {
-  defaultTextFontFace.set(font);
-  if (url) {
-    const face = new FontFace(font, `url(${url})`);
-    face.load().then(() => dispatch("loaded"));
-    document.fonts.add(face);
-    return () => {
-      document.fonts.delete(face);
-    };
-  }
-});
+<script lang="ts">
+
+    import { getGame } from "../core-contexts.js";
+    import { onMount } from "svelte";
+    const { defaultTextFontFace } = getGame();
+
+    interface Props {
+        /**
+     * THE DEFAULT FONT IS ONLY SET ON MOUNT. WRAP INSIDE A {key} IF THIS WILL CHANGE
+     */
+        font: string;
+        /**
+     * FONT FACES ARE ONLY AUTO-LOADED ON MOUNT.
+     * WRAPPING INSIDE A {key} MAY FIX THIS (not recommended)
+     * IF CHANGING FONTS, PRELOAD THEM ALL IN CSS AND UPDATE font PROP ONLY WITHIN {key} BLOCK
+     */
+        url?: string | null;
+        onload?: () => void;
+    }
+
+    let { font, url = null, onload }: Props = $props();
+
+    onMount(() => {
+        defaultTextFontFace.set(font);
+
+        if (url) {
+            const face = new FontFace(font, `url(${url})`);
+            face.load().then(() => onload?.());
+            document.fonts.add(face);
+            return () => {
+                document.fonts.delete(face);
+            }
+        }
+    })
+
 </script>

package/dist/extras/DefaultFontFace.svelte.d.ts

@@ -1,25 +1,16 @@
-import { SvelteComponent } from "svelte";
-declare const __propDef: {
-    props: {
-        /**
-             * THE DEFAULT FONT IS ONLY SET ON MOUNT. WRAP INSIDE A {key} IF THIS WILL CHANGE
-             */ font: string;
-        /**
-             * FONT FACES ARE ONLY AUTO-LOADED ON MOUNT.
-             * WRAPPING INSIDE A {key} MAY FIX THIS (not recommended)
-             * IF CHANGING FONTS, PRELOAD THEM ALL IN CSS AND UPDATE font PROP ONLY WITHIN {key} BLOCK
-             */ url?: string | null | undefined;
-    };
-    events: {
-        loaded: CustomEvent<any>;
-    } & {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-export type DefaultFontFaceProps = typeof __propDef.props;
-export type DefaultFontFaceEvents = typeof __propDef.events;
-export type DefaultFontFaceSlots = typeof __propDef.slots;
-export default class DefaultFontFace extends SvelteComponent<DefaultFontFaceProps, DefaultFontFaceEvents, DefaultFontFaceSlots> {
+interface Props {
+    /**
+ * THE DEFAULT FONT IS ONLY SET ON MOUNT. WRAP INSIDE A {key} IF THIS WILL CHANGE
+ */
+    font: string;
+    /**
+ * FONT FACES ARE ONLY AUTO-LOADED ON MOUNT.
+ * WRAPPING INSIDE A {key} MAY FIX THIS (not recommended)
+ * IF CHANGING FONTS, PRELOAD THEM ALL IN CSS AND UPDATE font PROP ONLY WITHIN {key} BLOCK
+ */
+    url?: string | null;
+    onload?: () => void;
 }
-export {};
+declare const DefaultFontFace: import("svelte").Component<Props, {}, "">;
+type DefaultFontFace = ReturnType<typeof DefaultFontFace>;
+export default DefaultFontFace;

package/dist/extras/FullScreenEventHandler.svelte

@@ -1,25 +1,39 @@
-<script>import { getGame } from "../core-contexts.js";
-import { onMount } from "svelte";
-import { KEYBOARD_ACTION } from "../controllers/keyboard.js";
-const context = getGame();
-export let key = "f";
-export let usesShift = true;
-export let usesCtrl = false;
-export let usesAlt = false;
-export let wrapper;
-onMount(() => {
-  return context.onKeyboardEvent(key, KEYBOARD_ACTION.DOWN, () => {
-    if (usesShift && !context.isKeyboardPressed("shift"))
-      return;
-    if (usesCtrl && !context.isKeyboardPressed("ctrl"))
-      return;
-    if (usesAlt && !context.isKeyboardPressed("alt"))
-      return;
-    if (document.fullscreenElement) {
-      document.exitFullscreen();
-    } else {
-      wrapper.requestFullscreen().catch();
+<script lang="ts">
+
+    import { getGame } from "../core-contexts.js";
+    import { onMount } from "svelte";
+    import { KEYBOARD_ACTION } from "../controllers/keyboard.js";
+
+    const context = getGame();
+    // ONLY OBSERVED ON MOUNT. NOT REACTIVE (good practice anyway)
+    interface Props {
+        key?: string;
+        usesShift?: boolean;
+        usesCtrl?: boolean;
+        usesAlt?: boolean;
+        wrapper: HTMLDivElement;
     }
-  });
-});
+
+    let {
+        key = "f",
+        usesShift = true,
+        usesCtrl = false,
+        usesAlt = false,
+        wrapper
+    }: Props = $props();
+
+    onMount(() => {
+        return context.onKeyboardEvent(key, KEYBOARD_ACTION.DOWN, () => {
+            if (usesShift && !context.isKeyboardPressed("shift")) return;
+            if (usesCtrl && !context.isKeyboardPressed("ctrl")) return;
+            if (usesAlt && !context.isKeyboardPressed("alt")) return;
+
+            if (document.fullscreenElement) {
+                document.exitFullscreen();
+            } else {
+                wrapper.requestFullscreen().catch();
+            }
+        });
+    })
+
 </script>

package/dist/extras/FullScreenEventHandler.svelte.d.ts

@@ -1,20 +1,10 @@
-import { SvelteComponent } from "svelte";
-declare const __propDef: {
-    props: {
-        key?: string | undefined;
-        usesShift?: boolean | undefined;
-        usesCtrl?: boolean | undefined;
-        usesAlt?: boolean | undefined;
-        wrapper: HTMLDivElement;
-    };
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {};
-};
-export type FullScreenEventHandlerProps = typeof __propDef.props;
-export type FullScreenEventHandlerEvents = typeof __propDef.events;
-export type FullScreenEventHandlerSlots = typeof __propDef.slots;
-export default class FullScreenEventHandler extends SvelteComponent<FullScreenEventHandlerProps, FullScreenEventHandlerEvents, FullScreenEventHandlerSlots> {
+interface Props {
+    key?: string;
+    usesShift?: boolean;
+    usesCtrl?: boolean;
+    usesAlt?: boolean;
+    wrapper: HTMLDivElement;
 }
-export {};
+declare const FullScreenEventHandler: import("svelte").Component<Props, {}, "">;
+type FullScreenEventHandler = ReturnType<typeof FullScreenEventHandler>;
+export default FullScreenEventHandler;

package/dist/extras/LayerPortal.svelte

@@ -1,24 +1,38 @@
-<script>import { getGame } from "../core-contexts";
-import { setupDrawable } from "../drawable";
-import { onMount } from "svelte";
-const game = getGame();
-export let name;
-const targets = /* @__PURE__ */ new Set();
-const draw = (core) => {
-  targets.forEach((t) => t.draw(core));
-};
-setupDrawable({
-  assign: (obj) => {
-    targets.add(obj);
-    return () => targets.delete(obj);
-  }
-});
-onMount(() => {
-  const context = game.getLayerByName(name);
-  if (!context)
-    return;
-  return context.assign({ draw });
-});
+<script lang="ts">
+
+    import { getGame } from "../core-contexts.js";
+    import { setupDrawable, type DrawableObject, type DrawFunction } from "../drawable.js";
+    import { onMount } from "svelte";
+
+    const game = getGame();
+
+    interface Props {
+        name: string;
+        children?: import('svelte').Snippet;
+    }
+
+    let { name, children }: Props = $props();
+    const targets = new Set<DrawableObject<null>>();
+    
+
+    const draw: DrawFunction<null> = (core) => {
+        targets.forEach(t => t.draw(core));
+    }
+
+    setupDrawable<null, null>({
+        assign: (obj) => {
+            targets.add(obj);
+            return () => targets.delete(obj);
+        }
+    });
+
+    onMount(() => {
+        const context = game.getLayerByName(name);
+        if (!context) return;
+
+        return context.assign({ draw });
+    })
+
 </script>
 
-<slot />
+{@render children?.()}

package/dist/extras/LayerPortal.svelte.d.ts

@@ -1,18 +1,7 @@
-import { SvelteComponent } from "svelte";
-declare const __propDef: {
-    props: {
-        name: string;
-    };
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {
-        default: {};
-    };
-};
-export type LayerPortalProps = typeof __propDef.props;
-export type LayerPortalEvents = typeof __propDef.events;
-export type LayerPortalSlots = typeof __propDef.slots;
-export default class LayerPortal extends SvelteComponent<LayerPortalProps, LayerPortalEvents, LayerPortalSlots> {
+interface Props {
+    name: string;
+    children?: import('svelte').Snippet;
 }
-export {};
+declare const LayerPortal: import("svelte").Component<Props, {}, "">;
+type LayerPortal = ReturnType<typeof LayerPortal>;
+export default LayerPortal;

package/dist/extras/SensibleDefaultStyles.svelte

@@ -1,8 +1,14 @@
-<script>let x;
+<script lang="ts">
+    interface Props {
+        children?: import('svelte').Snippet<[any]>;
+    }
+
+    let { children }: Props = $props();
+    let x: HTMLDivElement | undefined = $state();
 </script>
 
 <div class="game-wrapper" bind:this={x}>
-    <slot wrapper={x} />
+    {@render children?.({ wrapper: x, })}
 </div>
 
 <style>

package/dist/extras/SensibleDefaultStyles.svelte.d.ts

@@ -1,18 +1,6 @@
-import { SvelteComponent } from "svelte";
-declare const __propDef: {
-    props: Record<string, never>;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {
-        default: {
-            wrapper: HTMLDivElement;
-        };
-    };
-};
-export type SensibleDefaultStylesProps = typeof __propDef.props;
-export type SensibleDefaultStylesEvents = typeof __propDef.events;
-export type SensibleDefaultStylesSlots = typeof __propDef.slots;
-export default class SensibleDefaultStyles extends SvelteComponent<SensibleDefaultStylesProps, SensibleDefaultStylesEvents, SensibleDefaultStylesSlots> {
+interface Props {
+    children?: import('svelte').Snippet<[any]>;
 }
-export {};
+declare const SensibleDefaultStyles: import("svelte").Component<Props, {}, "">;
+type SensibleDefaultStyles = ReturnType<typeof SensibleDefaultStyles>;
+export default SensibleDefaultStyles;

package/dist/extras/Tweened.svelte

@@ -1,11 +1,30 @@
-<script>import { linear } from "svelte/easing";
-import { tweened } from "svelte/motion";
-export let duration = 200;
-export let value = 0;
-export let easing = linear;
-const tweening = tweened(null, { duration, easing });
-$:
-  tweening.set(value, { duration, easing });
+<script lang="ts">
+    import { linear } from "svelte/easing";
+    import { Tween, type TweenOptions } from "svelte/motion";
+
+    type Milliseconds = number;
+
+    interface Props {
+        duration?: Milliseconds;
+        value?: number;
+        easing?: TweenOptions<number>["easing"];
+        children?: import('svelte').Snippet<[{ smooth: number }]>;
+    }
+
+    let {
+        duration = 200,
+        value = 0,
+        easing = linear,
+        children
+    }: Props = $props();
+
+    //@ts-ignore
+    const tween = new Tween<number>(value, { duration, easing });
+
+    $effect(() => {
+        tween.set(value, { duration, easing });
+    });
+
 </script>
 
-<slot smooth={$tweening} />
+{@render children?.({ smooth: tween.current })}

package/dist/extras/Tweened.svelte.d.ts

@@ -1,23 +1,13 @@
-import { SvelteComponent } from "svelte";
-import { type TweenedOptions } from "svelte/motion";
-declare const __propDef: {
-    props: {
-        duration?: number | undefined;
-        value?: number | undefined;
-        easing?: TweenedOptions<number>["easing"];
-    };
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {
-        default: {
-            smooth: number;
-        };
-    };
-};
-export type TweenedProps = typeof __propDef.props;
-export type TweenedEvents = typeof __propDef.events;
-export type TweenedSlots = typeof __propDef.slots;
-export default class Tweened extends SvelteComponent<TweenedProps, TweenedEvents, TweenedSlots> {
+import { type TweenOptions } from "svelte/motion";
+type Milliseconds = number;
+interface Props {
+    duration?: Milliseconds;
+    value?: number;
+    easing?: TweenOptions<number>["easing"];
+    children?: import('svelte').Snippet<[{
+        smooth: number;
+    }]>;
 }
-export {};
+declare const Tweened: import("svelte").Component<Props, {}, "">;
+type Tweened = ReturnType<typeof Tweened>;
+export default Tweened;

package/dist/primitives/Area.svelte

@@ -1,25 +1,49 @@
-<script>import { setupDrawable } from "../drawable.js";
-import { onMount } from "svelte";
-export let x = 0;
-export let y = 0;
-export let w;
-export let h;
-export let center = false;
-const targets = /* @__PURE__ */ new Set();
-const draw = function({ width, height, ctx }, offset) {
-  targets.forEach((f) => f.draw({ width, height, ctx }, { x: offset.x + x - (center ? w / 2 : 0), y: offset.y + y - (center ? h / 2 : 0), w, h }));
-};
-let register = setupDrawable({
-  assign: (ctx) => {
-    targets.add(ctx);
-    return () => {
-      targets.delete(ctx);
+<script lang="ts">
+
+    import { setupDrawable, type DrawFunction } from "../drawable.js";
+    import { onMount } from "svelte";
+
+    interface Props {
+        x?: number;
+        y?: number;
+        w: number;
+        h: number;
+        /**
+     * TRUE = ALIGN CENTER
+     * FALSE (default) = ALIGN TOP LEFT
+     */
+        center?: boolean;
+        children?: import('svelte').Snippet;
+    }
+
+    let {
+        x = 0,
+        y = 0,
+        w,
+        h,
+        center = false,
+        children
+    }: Props = $props();
+
+    const targets = new Set<{ draw: DrawFunction<{x: number, y: number, w: number, h: number}> }>();
+
+    const draw: DrawFunction<{x: number, y: number}> = function ( { width, height, ctx }, offset ) {
+        targets.forEach(f => f.draw({ width, height, ctx }, { x: offset.x + x - (center ? w / 2 : 0), y: offset.y + y - (center ? h / 2 : 0), w, h }));
     };
-  }
-});
-onMount(() => {
-  return register({ draw });
-});
+
+    let register = setupDrawable<{x: number, y: number}, {x: number, y: number, w: number, h: number}>({
+        assign: (ctx) => {
+            targets.add(ctx);
+            return () => {
+                targets.delete(ctx);
+            };
+        },
+    });
+
+    onMount(() => {
+        return register({ draw });
+    });
+
 </script>
 
-<slot/>
+{@render children?.()}

package/dist/primitives/Area.svelte.d.ts

@@ -1,25 +1,15 @@
-import { SvelteComponent } from "svelte";
-declare const __propDef: {
-    props: {
-        x?: number | undefined;
-        y?: number | undefined;
-        w: number;
-        h: number;
-        /**
-             * TRUE = ALIGN CENTER
-             * FALSE (default) = ALIGN TOP LEFT
-             */ center?: boolean | undefined;
-    };
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {
-        default: {};
-    };
-};
-export type AreaProps = typeof __propDef.props;
-export type AreaEvents = typeof __propDef.events;
-export type AreaSlots = typeof __propDef.slots;
-export default class Area extends SvelteComponent<AreaProps, AreaEvents, AreaSlots> {
+interface Props {
+    x?: number;
+    y?: number;
+    w: number;
+    h: number;
+    /**
+ * TRUE = ALIGN CENTER
+ * FALSE (default) = ALIGN TOP LEFT
+ */
+    center?: boolean;
+    children?: import('svelte').Snippet;
 }
-export {};
+declare const Area: import("svelte").Component<Props, {}, "">;
+type Area = ReturnType<typeof Area>;
+export default Area;

package/dist/primitives/Empty.svelte

@@ -1,2 +1,7 @@
-<script></script>
-<slot />
+<script lang="ts">
+	interface Props {
+		children?: import('svelte').Snippet;
+	}
+
+	let { children }: Props = $props();</script>
+{@render children?.()}

package/dist/primitives/Empty.svelte.d.ts

@@ -1,16 +1,6 @@
-import { SvelteComponent } from "svelte";
-declare const __propDef: {
-    props: Record<string, never>;
-    events: {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots: {
-        default: {};
-    };
-};
-export type EmptyProps = typeof __propDef.props;
-export type EmptyEvents = typeof __propDef.events;
-export type EmptySlots = typeof __propDef.slots;
-export default class Empty extends SvelteComponent<EmptyProps, EmptyEvents, EmptySlots> {
+interface Props {
+    children?: import('svelte').Snippet;
 }
-export {};
+declare const Empty: import("svelte").Component<Props, {}, "">;
+type Empty = ReturnType<typeof Empty>;
+export default Empty;

package/dist/primitives/Inset.svelte

@@ -1,29 +1,48 @@
-<script>import { setupDrawable } from "../drawable.js";
-import { onMount } from "svelte";
-export let left = 0;
-export let right = 0;
-export let top = 0;
-export let bottom = 0;
-const targets = /* @__PURE__ */ new Set();
-const draw = function({ width, height, ctx }, o) {
-  targets.forEach((f) => f.draw({ width, height, ctx }, {
-    x: o.x + left,
-    y: o.y + top,
-    w: o.x - left - right,
-    h: o.y - top - bottom
-  }));
-};
-let register = setupDrawable({
-  assign: (ctx) => {
-    targets.add(ctx);
-    return () => {
-      targets.delete(ctx);
+<script lang="ts">
+
+    import { setupDrawable, type DrawFunction } from "../drawable.js";
+    import { onMount } from "svelte";
+
+    interface Props {
+        left?: number;
+        right?: number;
+        top?: number;
+        bottom?: number;
+        children?: import('svelte').Snippet;
+    }
+
+    let {
+        left = 0,
+        right = 0,
+        top = 0,
+        bottom = 0,
+        children
+    }: Props = $props();
+
+    const targets = new Set<{ draw: DrawFunction<{x: number, y: number, w: number, h: number}> }>();
+
+    const draw: DrawFunction<{x: number, y: number, w: number, h: number}> = function ( { width, height, ctx }, o ) {
+        targets.forEach(f => f.draw({ width, height, ctx }, { 
+            x: o.x + left, 
+            y: o.y + top, 
+            w: o.w - (left + right), 
+            h: o.h - (top + bottom),
+        }));
     };
-  }
-});
-onMount(() => {
-  return register({ draw });
-});
+
+    let register = setupDrawable<{x: number, y: number, w: number, h: number}, {x: number, y: number, w: number, h: number}>({
+        assign: (ctx) => {
+            targets.add(ctx);
+            return () => {
+                targets.delete(ctx);
+            };
+        },
+    });
+
+    onMount(() => {
+        return register({ draw });
+    });
+
 </script>
 
-<slot/>
+{@render children?.()}