neko-vue 0.1.0

package/dist/index-BjAaI8iZ.d.mts

@@ -0,0 +1,128 @@
+//#region src/types/index.d.ts
+/** Sprite edge length in CSS pixels for viewport bounds (`clientWidth/innerHeight - this`). */
+declare const NEKOJS_SPRITE_SIZE: 32;
+/**
+ * Pet behavior / AI mode. Values match the engine; click cycles when `allowBehaviorChange` is true.
+ */
+declare enum BehaviorMode {
+  /** Follow the pointer. */
+  ChaseMouse = 0,
+  /** Flee from the pointer. */
+  RunAwayFromMouse = 1,
+  /** Wander randomly. */
+  RunAroundRandomly = 2,
+  /** Walk the screen edges. */
+  PaceAroundScreen = 3,
+  /** Ball-style chase (engine: run-around mode). */
+  BallChase = 4,
+  /** Hold the current position (no wandering). */
+  StayStill = 5,
+  /**
+   * Walk back to the spawn position from `createNeko` options, then stay there until the next mode.
+   * Last step when clicking through the behavior cycle.
+   */
+  ReturnHomeAndStay = 6
+}
+/** Short camelCase aliases — same values as {@link BehaviorMode}. */
+declare const BehaviorModes: {
+  readonly chase: BehaviorMode.ChaseMouse;
+  readonly runAway: BehaviorMode.RunAwayFromMouse;
+  readonly random: BehaviorMode.RunAroundRandomly;
+  readonly pace: BehaviorMode.PaceAroundScreen;
+  readonly ballChase: BehaviorMode.BallChase;
+  readonly stayStill: BehaviorMode.StayStill;
+  readonly returnHome: BehaviorMode.ReturnHomeAndStay;
+};
+/**
+ * Default pet-click order when {@link NekoOptions.behaviorCycle} is omitted (full classic cycle).
+ */
+declare const DEFAULT_NEKO_BEHAVIOR_CYCLE: readonly BehaviorMode[];
+/**
+ * Options for {@link createNeko}.
+ *
+ * Note: coordinates use `options.startX || 0`, so `0` is valid; omitting `startX`/`startY`
+ * falls back to `0`. Horizontal bounds use `document.documentElement.clientWidth -
+ * {@link NEKOJS_SPRITE_SIZE}`; vertical uses `window.innerHeight - {@link NEKOJS_SPRITE_SIZE}`.
+ */
+interface NekoOptions {
+  /**
+   * Pixels per logic tick (default: 24; logic runs ~5 ticks/sec).
+   */
+  speed?: number;
+  /**
+   * Render frame rate (default: 120).
+   */
+  fps?: number;
+  /**
+   * Initial {@link BehaviorMode} when the instance is **created**. Clicks on the pet cycle the
+   * live mode in the engine; changing this option later does **not** recreate the pet or override
+   * the current mode (see wrapper behavior).
+   */
+  behaviorMode?: BehaviorMode;
+  /**
+   * Distance at which the pet is considered idle (default: 6).
+   */
+  idleThreshold?: number;
+  /**
+   * In {@link BehaviorMode.ChaseMouse}, keep at least this many CSS pixels between the pet’s
+   * movement anchor and the pointer (default / omitted: 0 = original “hug the cursor” behavior).
+   */
+  cursorStandoffPx?: number;
+  /**
+   * Whether clicking the pet cycles behavior (default: true).
+   */
+  allowBehaviorChange?: boolean;
+  /**
+   * Ordered modes advanced on each pet click when {@link allowBehaviorChange} is true. Order is
+   * click order (wraps after the last). Omit to use {@link DEFAULT_NEKO_BEHAVIOR_CYCLE}. Non-integer
+   * or out-of-range values are ignored; if none remain, the default cycle is used.
+   */
+  behaviorCycle?: readonly BehaviorMode[];
+  /**
+   * Initial X position. `0` is valid; omit for default `0`.
+   */
+  startX?: number;
+  /**
+   * Initial Y position. `0` is valid; omit for default `0`.
+   */
+  startY?: number;
+}
+/**
+ * Minimal handle returned by {@link createNeko} / {@link loadNekoRuntime}. The concrete {@link Neko}
+ * class may expose additional helpers (e.g. `isIdle`).
+ */
+interface NekoInstance {
+  /** Starts or resumes the animation interval. */
+  start(): void;
+  /** Stops the interval without removing the pet from the DOM. */
+  stop(): void;
+  /** Stops the loop, removes listeners, and deletes the pet element. */
+  destroy(): void;
+  /**
+   * Current engine behavior mode (updated when the user clicks the pet if `allowBehaviorChange` is
+   * true). The bundled `Neko` class implements this; mocks may omit it.
+   */
+  behaviorMode?: BehaviorMode;
+  /** Current X in viewport pixels (bundled `Neko` implements). */
+  x?: number;
+  /** Current Y in viewport pixels (bundled `Neko` implements). */
+  y?: number;
+  /**
+   * Spawn / home top-left from `createNeko` (`startX` / `startY`); return-home uses this. Bundled
+   * `Neko` implements.
+   */
+  homeX?: number;
+  homeY?: number;
+}
+type CreateNekoFn = (options?: NekoOptions) => NekoInstance;
+interface LoadNekoRuntimeOptions {
+  /** Abort if the bundled runtime has not loaded within this time (ms). Default: 30000. */
+  timeoutMs?: number;
+}
+declare global {
+  interface Window {
+    createNeko?: CreateNekoFn;
+  }
+}
+//#endregion
+export { LoadNekoRuntimeOptions as a, NekoOptions as c, DEFAULT_NEKO_BEHAVIOR_CYCLE as i, BehaviorModes as n, NEKOJS_SPRITE_SIZE as o, CreateNekoFn as r, NekoInstance as s, BehaviorMode as t };

package/dist/index.d.mts

@@ -0,0 +1,17 @@
+import { i as resolveStartPosition, n as NekoStartCorner, r as cornerToStartXY } from "./nekoPlacement-fXmlU6ys.mjs";
+import { a as LoadNekoRuntimeOptions, c as NekoOptions, i as DEFAULT_NEKO_BEHAVIOR_CYCLE, n as BehaviorModes, o as NEKOJS_SPRITE_SIZE, r as CreateNekoFn, s as NekoInstance, t as BehaviorMode } from "./index-BjAaI8iZ.mjs";
+import { t as loadNekoRuntime } from "./loadNekoRuntime-DLd1lr8Y.mjs";
+import { i as useNeko, n as NekoFollowMode, r as UseNekoOptions, t as _default } from "./NekoPet-B9k9Bf1o.mjs";
+
+//#region src/utils/debugLog.d.ts
+/** Opt-in `console` helper; prefix keeps DevTools filter easy. */
+declare function nekoVueDebug(enabled: boolean, label: string, ...args: unknown[]): void;
+//#endregion
+//#region src/utils/prefersReducedMotion.d.ts
+/**
+ * True when the user has requested less motion (OS / browser setting).
+ * Safe on SSR (returns false) and when `matchMedia` is missing.
+ */
+declare function prefersReducedMotion(): boolean;
+//#endregion
+export { BehaviorMode, BehaviorModes, type CreateNekoFn, DEFAULT_NEKO_BEHAVIOR_CYCLE, type LoadNekoRuntimeOptions, NEKOJS_SPRITE_SIZE, type NekoFollowMode, type NekoInstance, type NekoOptions, _default as NekoPet, type NekoStartCorner, type UseNekoOptions, cornerToStartXY, loadNekoRuntime, nekoVueDebug, prefersReducedMotion, resolveStartPosition, useNeko };

package/dist/index.mjs

@@ -0,0 +1,5 @@
+import { i as NEKOJS_SPRITE_SIZE, n as BehaviorModes, r as DEFAULT_NEKO_BEHAVIOR_CYCLE, t as BehaviorMode } from "./types-Ctrldouo.mjs";
+import { n as resolveStartPosition, r as nekoVueDebug, t as cornerToStartXY } from "./nekoPlacement-DUdnhZoX.mjs";
+import { t as loadNekoRuntime } from "./loadNekoRuntime-CskWI70T.mjs";
+import { n as useNeko, r as prefersReducedMotion, t as NekoPet_default } from "./NekoPet-DMPjoHm0.mjs";
+export { BehaviorMode, BehaviorModes, DEFAULT_NEKO_BEHAVIOR_CYCLE, NEKOJS_SPRITE_SIZE, NekoPet_default as NekoPet, cornerToStartXY, loadNekoRuntime, nekoVueDebug, prefersReducedMotion, resolveStartPosition, useNeko };

package/dist/loadNekoRuntime-CskWI70T.mjs

@@ -0,0 +1,41 @@
+//#region src/runtime/loadNekoRuntime.ts
+function isBrowser() {
+	return typeof document !== "undefined";
+}
+function getCreateNekoFromGlobal() {
+	if (typeof globalThis === "undefined") return void 0;
+	const fn = globalThis.createNeko;
+	return typeof fn === "function" ? fn : void 0;
+}
+let bundledLoadPromise = null;
+/**
+* Dynamically imports the bundled typed runtime (`./nekojsRuntime.ts`). Defines `window.createNeko`.
+*/
+async function importBundledNeko() {
+	await import("./nekojsRuntime-DJI-YkCi.mjs");
+	const fn = getCreateNekoFromGlobal();
+	if (!fn) throw new Error("neko-vue: bundled neko.js did not define `createNeko`.");
+	return fn;
+}
+/**
+* Ensures `createNeko` exists on `globalThis`: uses a global if already present, otherwise loads the
+* **bundled** runtime (dynamic import, no network). Used internally by {@link useNeko}; consumers
+* normally rely on `useNeko` / `<NekoPet>` only.
+*/
+function loadNekoRuntime(options = {}) {
+	if (!isBrowser()) return Promise.reject(/* @__PURE__ */ new Error("neko-vue: loadNekoRuntime() can only run in a browser (no `document`). Use <ClientOnly> / `.client` components in Nuxt."));
+	const existingFn = getCreateNekoFromGlobal();
+	if (existingFn) return Promise.resolve(existingFn);
+	const timeoutMs = options.timeoutMs ?? 3e4;
+	if (!bundledLoadPromise) bundledLoadPromise = Promise.race([importBundledNeko(), new Promise((_, reject) => {
+		window.setTimeout(() => {
+			reject(/* @__PURE__ */ new Error(`neko-vue: timed out after ${timeoutMs}ms loading bundled neko.js`));
+		}, timeoutMs);
+	})]).catch((err) => {
+		bundledLoadPromise = null;
+		throw err;
+	});
+	return bundledLoadPromise;
+}
+//#endregion
+export { loadNekoRuntime as t };

package/dist/loadNekoRuntime-DLd1lr8Y.d.mts

@@ -0,0 +1,11 @@
+import { a as LoadNekoRuntimeOptions, r as CreateNekoFn } from "./index-BjAaI8iZ.mjs";
+
+//#region src/runtime/loadNekoRuntime.d.ts
+/**
+ * Ensures `createNeko` exists on `globalThis`: uses a global if already present, otherwise loads the
+ * **bundled** runtime (dynamic import, no network). Used internally by {@link useNeko}; consumers
+ * normally rely on `useNeko` / `<NekoPet>` only.
+ */
+declare function loadNekoRuntime(options?: LoadNekoRuntimeOptions): Promise<CreateNekoFn>;
+//#endregion
+export { loadNekoRuntime as t };

package/dist/nekoPlacement-DUdnhZoX.mjs

@@ -0,0 +1,76 @@
+import "./types-Ctrldouo.mjs";
+//#region src/utils/debugLog.ts
+/** Opt-in `console` helper; prefix keeps DevTools filter easy. */
+function nekoVueDebug(enabled, label, ...args) {
+	if (enabled) console.log(`[neko-vue] ${label}`, ...args);
+}
+//#endregion
+//#region src/placement/nekoPlacement.ts
+function cornerToStartXY(corner, spriteSize = 32, debug = false) {
+	const vw = document.documentElement.clientWidth;
+	const vh = window.innerHeight;
+	nekoVueDebug(debug, "cornerToStartXY viewport", {
+		corner,
+		spriteSize,
+		documentElementClientWidth: vw,
+		windowInnerHeight: vh,
+		note: "If vw/vh are 0, corner math collapses to 0 — expect a second recreate after layout."
+	});
+	switch (corner) {
+		case "top-left": return {
+			startX: 0,
+			startY: 0
+		};
+		case "top-right": return {
+			startX: Math.max(0, vw - spriteSize),
+			startY: 0
+		};
+		case "bottom-left": return {
+			startX: 0,
+			startY: Math.max(0, vh - spriteSize)
+		};
+		case "bottom-right": return {
+			startX: Math.max(0, vw - spriteSize),
+			startY: Math.max(0, vh - spriteSize)
+		};
+	}
+}
+/**
+* Resolves `startX` / `startY` for `createNeko`. Explicit coordinates win per axis.
+* Then anchor top-left (when element is given). Then corner for any axis still unset.
+*/
+function resolveStartPosition(input, debug = false) {
+	nekoVueDebug(debug, "resolveStartPosition input", {
+		startX: input.startX,
+		startY: input.startY,
+		startCorner: input.startCorner,
+		hasAnchor: Boolean(input.anchorElement)
+	});
+	let startX = input.startX;
+	let startY = input.startY;
+	const el = input.anchorElement;
+	if (el) {
+		const r = el.getBoundingClientRect();
+		nekoVueDebug(debug, "resolveStartPosition anchor rect", {
+			left: r.left,
+			top: r.top,
+			width: r.width,
+			height: r.height
+		});
+		if (startX === void 0) startX = Math.round(r.left);
+		if (startY === void 0) startY = Math.round(r.top);
+	}
+	if (input.startCorner !== void 0) {
+		const c = cornerToStartXY(input.startCorner, 32, debug);
+		if (startX === void 0) startX = c.startX;
+		if (startY === void 0) startY = c.startY;
+	}
+	const out = {
+		startX: startX ?? 0,
+		startY: startY ?? 0
+	};
+	nekoVueDebug(debug, "resolveStartPosition result", out);
+	return out;
+}
+//#endregion
+export { resolveStartPosition as n, nekoVueDebug as r, cornerToStartXY as t };

package/dist/nekoPlacement-fXmlU6ys.d.mts

@@ -0,0 +1,23 @@
+//#region src/placement/nekoPlacement.d.ts
+/** Viewport corner used to derive `startX` / `startY` (wrapper-only). */
+type NekoStartCorner = "top-left" | "top-right" | "bottom-left" | "bottom-right";
+declare function cornerToStartXY(corner: NekoStartCorner, spriteSize?: number, debug?: boolean): {
+  startX: number;
+  startY: number;
+};
+type NekoPlacementInput = {
+  startX?: number;
+  startY?: number;
+  startCorner?: NekoStartCorner; /** Resolved element (e.g. from `anchorRef` or `querySelector`). */
+  anchorElement?: HTMLElement | null;
+};
+/**
+ * Resolves `startX` / `startY` for `createNeko`. Explicit coordinates win per axis.
+ * Then anchor top-left (when element is given). Then corner for any axis still unset.
+ */
+declare function resolveStartPosition(input: NekoPlacementInput, debug?: boolean): {
+  startX: number;
+  startY: number;
+};
+//#endregion
+export { resolveStartPosition as i, NekoStartCorner as n, cornerToStartXY as r, NekoPlacementInput as t };