@mentra/engine 0.1.0-beta.0

package/src/utils/storage/storage.ts

@@ -0,0 +1,101 @@
+// @ts-nocheck
+import {createMMKV, type MMKV} from "react-native-mmkv"
+import {result as Res, Result} from "typesafe-ts"
+
+/**
+ * Thrown by load() when the key has no stored value. Callers that treat a
+ * missing key as an expected state (e.g. first run) should branch on
+ * `instanceof StorageValueNotFoundError` rather than matching the message.
+ */
+export class StorageValueNotFoundError extends Error {
+  constructor(key: string) {
+    super(`No value found for ${key}`)
+    this.name = "StorageValueNotFoundError"
+  }
+}
+
+class MMKVStorage {
+  private _store?: MMKV
+
+  private get store(): MMKV {
+    if (!this._store) {
+      this._store = createMMKV()
+    }
+    return this._store
+  }
+
+  public save(key: string, value: unknown): Result<void, Error> {
+    return this.saveString(key, JSON.stringify(value))
+  }
+
+  public load<T>(key: string): Result<T, Error> {
+    return Res.try(() => {
+      const loadedString = this.store.getString(key) ?? ""
+      if (loadedString === "") {
+        throw new StorageValueNotFoundError(key)
+      }
+      const value = JSON.parse(loadedString) as T
+      return value
+    })
+  }
+
+  private saveString(key: string, value: string): Result<void, Error> {
+    this.store.set(key, value)
+    return Res.ok(undefined)
+  }
+
+  public getAllKeys(): string[] {
+    return this.store.getAllKeys()
+  }
+
+  public removeMultiple(keys: string[]): Result<void, Error> {
+    let success = true
+    for (const key of keys) {
+      const res = this.store.remove(key)
+      if (!res) {
+        success = false
+      }
+    }
+    if (!success) {
+      console.error("Failed to remove one or more keys")
+      return Res.error(new Error("Failed to remove one or more keys"))
+    }
+    return Res.ok(undefined)
+  }
+
+  public loadSubKeys(key: string): Result<Record<string, unknown>, Error> {
+    return Res.try(() => {
+      // return the key value pair of any keys that start with the given key and contain a colon:
+      const keys = this.store.getAllKeys()
+
+      const subKeys = keys.filter((k) => k.startsWith(key) && k.includes(":"))
+
+      if (subKeys.length === 0) {
+        throw new Error(`No subkeys found for ${key}`)
+      }
+
+      let subKeysObject: Record<string, unknown> = {}
+
+      for (const subKey of subKeys) {
+        const res = this.load(subKey)
+        if (res.is_ok()) {
+          subKeysObject[subKey] = res.value
+        }
+      }
+
+      return subKeysObject
+    })
+  }
+
+  public remove(key: string): Result<void, Error> {
+    this.store.remove(key)
+    return Res.ok(undefined)
+  }
+
+  public clearAll(): Result<void, Error> {
+    this.store.clearAll()
+    return Res.ok(undefined)
+  }
+}
+
+export const storage = new MMKVStorage()

package/src/utils/storage/zip.ts

@@ -0,0 +1,13 @@
+import {Directory} from "expo-file-system"
+
+export function printDirectory(directory: Directory, indent: number = 0) {
+  console.log(`${" ".repeat(indent)} + ${directory.name}`)
+  const contents = directory.list()
+  for (const item of contents) {
+    if (item instanceof Directory) {
+      printDirectory(item, indent + 2)
+    } else {
+      console.log(`${" ".repeat(indent + 2)} - ${item.name} (${item.size} bytes)`)
+    }
+  }
+}

package/src/utils/timers/index.ts

@@ -0,0 +1,2 @@
+import {BgTimer, throttle, debounce} from "./timers"
+export {BgTimer, throttle, debounce}

package/src/utils/timers/timers.ts

@@ -0,0 +1,139 @@
+// until https://github.com/tconns/react-native-nitro-bg-timer/issues/2 is resolved, we need to use this class to disable this package on iOS:
+
+import {Platform} from "react-native"
+
+type NitroTimerApi = {
+  setInterval: (callback: () => void, delay: number) => number
+  clearInterval: (intervalId: number) => void
+  setTimeout: (callback: () => void, delay: number) => number
+  clearTimeout: (timeoutId: number) => void
+}
+
+let nitroTimer: NitroTimerApi | null | undefined
+let nitroDisabled = false
+let warnedUnavailable = false
+
+function warnUnavailable(reason: string) {
+  if (warnedUnavailable) {
+    return
+  }
+  warnedUnavailable = true
+  console.warn(`BgTimer: ${reason}, using JS timers`)
+}
+
+function getNitroTimer(): NitroTimerApi | null {
+  if (nitroDisabled || Platform.OS !== "android") {
+    return null
+  }
+
+  // react-native-nitro-bg-timer calls createHybridObject() at require() time. On dev
+  // builds with a stale native binary that throws NPE, React Native still surfaces a
+  // red LogBox error even when the exception is caught. Skip nitro in __DEV__ unless
+  // explicitly enabled after a native rebuild (bun android).
+  if (__DEV__ && process.env.EXPO_PUBLIC_USE_NITRO_BG_TIMER !== "true") {
+    warnUnavailable("nitro bg-timer disabled in dev (set EXPO_PUBLIC_USE_NITRO_BG_TIMER=true after native rebuild)")
+    return null
+  }
+
+  if (nitroTimer !== undefined) {
+    return nitroTimer
+  }
+
+  try {
+    const {isRuntimeAlive} = require("react-native-nitro-modules") as {isRuntimeAlive?: () => boolean}
+    if (typeof isRuntimeAlive === "function" && !isRuntimeAlive()) {
+      nitroTimer = null
+      warnUnavailable("nitro runtime is not alive")
+      return nitroTimer
+    }
+
+    const {BackgroundTimer} = require("react-native-nitro-bg-timer") as {BackgroundTimer?: NitroTimerApi}
+    nitroTimer =
+      BackgroundTimer &&
+      typeof BackgroundTimer.setTimeout === "function" &&
+      typeof BackgroundTimer.setInterval === "function" &&
+      typeof BackgroundTimer.clearTimeout === "function" &&
+      typeof BackgroundTimer.clearInterval === "function"
+        ? BackgroundTimer
+        : null
+  } catch {
+    nitroTimer = null
+    nitroDisabled = true
+  }
+
+  if (!nitroTimer) {
+    warnUnavailable("react-native-nitro-bg-timer unavailable")
+  }
+  return nitroTimer
+}
+
+function withNitro<T>(run: (api: NitroTimerApi) => T, fallback: () => T): T {
+  const api = getNitroTimer()
+  if (!api) {
+    return fallback()
+  }
+  try {
+    return run(api)
+  } catch (error) {
+    nitroDisabled = true
+    nitroTimer = null
+    console.warn("BgTimer: nitro timer failed, using JS timers", error)
+    return fallback()
+  }
+}
+
+export class BgTimer {
+  static setInterval(callback: () => void, delay: number): number {
+    return withNitro(
+      (api) => api.setInterval(callback, delay),
+      () => setInterval(callback, delay) as unknown as number,
+    )
+  }
+
+  static clearInterval(intervalId: number): void {
+    withNitro(
+      (api) => api.clearInterval(intervalId),
+      () => clearInterval(intervalId),
+    )
+  }
+
+  static setTimeout(callback: () => void, delay: number): number {
+    return withNitro(
+      (api) => api.setTimeout(callback, delay),
+      () => setTimeout(callback, delay) as unknown as number,
+    )
+  }
+
+  static clearTimeout(timeoutId: number): void {
+    withNitro(
+      (api) => api.clearTimeout(timeoutId),
+      () => clearTimeout(timeoutId),
+    )
+  }
+}
+
+export function throttle<T extends (...args: any[]) => any>(fn: T, ms: number): (...args: Parameters<T>) => void {
+  let lastCalled = 0
+
+  return (...args: Parameters<T>) => {
+    const now = Date.now()
+    if (now - lastCalled >= ms) {
+      lastCalled = now
+      fn(...args)
+    }
+  }
+}
+
+export function debounce<T extends (...args: any[]) => any>(fn: T, ms: number): (...args: Parameters<T>) => void {
+  let timeoutId: number | null = null
+
+  return (...args: Parameters<T>) => {
+    if (timeoutId) {
+      BgTimer.clearTimeout(timeoutId)
+    }
+    timeoutId = BgTimer.setTimeout(() => {
+      fn(...args)
+      timeoutId = null
+    }, ms)
+  }
+}