@symbiote-native/keep-awake 0.0.1

package/src/vue/composables/use-keep-awake/index.ts

@@ -0,0 +1,36 @@
+// Vue lifecycle wiring over the framework-agnostic core (core/keep-awake.ts) — activates on
+// mount, deactivates on unmount, mirroring React's useKeepAwake hook. Vue has no useId
+// equivalent, so the default tag comes from a small monotonically-incrementing module-local
+// counter instead — simplest robust way to give each composable instance its own tag when the
+// caller doesn't supply one.
+import { onMounted, onUnmounted } from '@vue/runtime-core';
+import {
+  activateKeepAwakeAsync,
+  addListener,
+  deactivateKeepAwake,
+  type KeepAwakeOptions,
+} from '../../../core';
+
+let tagCounter = 0;
+
+export function useKeepAwake(tag?: string, options?: KeepAwakeOptions): void {
+  const tagOrDefault = tag ?? `keep-awake-tag-${++tagCounter}`;
+
+  onMounted(() => {
+    activateKeepAwakeAsync(tagOrDefault)
+      .then(() => {
+        if (options?.listener) {
+          addListener(tagOrDefault, options.listener);
+        }
+      })
+      .catch(() => {});
+  });
+
+  onUnmounted(() => {
+    if (options?.suppressDeactivateWarnings) {
+      deactivateKeepAwake(tagOrDefault).catch(() => {});
+    } else {
+      deactivateKeepAwake(tagOrDefault);
+    }
+  });
+}

package/src/vue/composables/use-keep-awake/use-keep-awake.test.ts

@@ -0,0 +1,76 @@
+// Co-located Vue-driven test (ADR 0025) for useKeepAwake. See battery's
+// use-low-power-mode.test.ts for the shared rationale.
+
+import { defineComponent, h } from '@vue/runtime-core';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mount, unmount } from '@symbiote-native/vue';
+import { installFabric } from '@symbiote-native/test-utils';
+import { useKeepAwake } from './index';
+
+const ROOT_TAG = 9954;
+
+const activateKeepAwakeAsyncMock = vi.fn(async (_tag: string) => undefined);
+const addListenerMock = vi.fn();
+const deactivateKeepAwakeMock = vi.fn(async (_tag: string) => undefined);
+
+vi.mock('../../../core', () => ({
+  activateKeepAwakeAsync: (tag: string) => activateKeepAwakeAsyncMock(tag),
+  addListener: (...args: unknown[]) => addListenerMock(...args),
+  deactivateKeepAwake: (tag: string) => deactivateKeepAwakeMock(tag),
+}));
+
+const fabric = installFabric();
+
+beforeEach(() => {
+  fabric.reset();
+  activateKeepAwakeAsyncMock.mockClear();
+  addListenerMock.mockClear();
+  deactivateKeepAwakeMock.mockClear();
+  activateKeepAwakeAsyncMock.mockResolvedValue(undefined);
+  deactivateKeepAwakeMock.mockResolvedValue(undefined);
+});
+
+afterEach(() => unmount(ROOT_TAG));
+
+function mountKeepAwake(tag?: string): void {
+  mount(
+    ROOT_TAG,
+    defineComponent({
+      setup: () => {
+        useKeepAwake(tag);
+        return () => h('symbiote-text', {}, 'keep-awake');
+      },
+    }),
+  );
+}
+
+describe('useKeepAwake (Vue)', () => {
+  it('activates a default tag on mount', async () => {
+    mountKeepAwake();
+
+    await vi.waitFor(() => expect(activateKeepAwakeAsyncMock).toHaveBeenCalledTimes(1));
+    expect(typeof activateKeepAwakeAsyncMock.mock.calls[0][0]).toBe('string');
+  });
+
+  it('activates the explicit tag when one is given', async () => {
+    mountKeepAwake('custom-tag');
+
+    await vi.waitFor(() => expect(activateKeepAwakeAsyncMock).toHaveBeenCalledWith('custom-tag'));
+  });
+
+  it('deactivates the same tag on unmount', async () => {
+    mountKeepAwake('custom-tag');
+    await vi.waitFor(() => expect(activateKeepAwakeAsyncMock).toHaveBeenCalledTimes(1));
+
+    unmount(ROOT_TAG);
+
+    expect(deactivateKeepAwakeMock).toHaveBeenCalledWith('custom-tag');
+  });
+
+  it('never touches addListener when no options are given', async () => {
+    mountKeepAwake('custom-tag');
+
+    await vi.waitFor(() => expect(activateKeepAwakeAsyncMock).toHaveBeenCalledTimes(1));
+    expect(addListenerMock).not.toHaveBeenCalled();
+  });
+});

package/src/vue/index.ts

@@ -0,0 +1,16 @@
+// @symbiote-native/keep-awake/vue: the Vue entry over the framework-agnostic core. The
+// lifecycle bucket is `composables/` (never `hooks/`, that's React's term) — see
+// adapters/vue/src/composables for the same convention.
+
+export { useKeepAwake } from './composables/use-keep-awake';
+export {
+  ExpoKeepAwakeTag,
+  isAvailableAsync,
+  activateKeepAwakeAsync,
+  deactivateKeepAwake,
+  addListener,
+  type KeepAwakeEvent,
+  type KeepAwakeListener,
+  type KeepAwakeOptions,
+  type EventSubscription,
+} from '../core';