@multiplatform.one/platform 6.0.0

package/src/helpers.tsx

@@ -0,0 +1,62 @@
+import type { ComponentType } from "react";
+
+const isPerformanceNow = typeof performance !== "undefined" && performance.now;
+const date = isPerformanceNow ? performance : Date;
+let _previousUnique: number;
+
+export function fastUnique() {
+  let unique = date.now();
+  while (unique === _previousUnique) {
+    unique = date.now();
+  }
+  _previousUnique = unique;
+  if (isPerformanceNow) return Date.now() + unique.toString();
+  return unique.toString();
+}
+
+export function isText(children: unknown) {
+  if (Array.isArray(children)) {
+    return (
+      children.length > 1 &&
+      typeof children[0] === "string" &&
+      "_owner" in children[1] &&
+      "_store" in children[1] &&
+      "key" in children[1] &&
+      "props" in children[1] &&
+      "ref" in children[1] &&
+      "type" in children[1]
+    );
+  }
+  return typeof children === "string";
+}
+
+export function createWithLayout<LayoutProps>(
+  Layout: ComponentType<LayoutProps>,
+  extraLayouts: WithLayout[] = [],
+  layoutProps?: Omit<LayoutProps, "children">,
+): WithLayout {
+  return ((Component: ComponentType<unknown>) => {
+    return flattenLayouts(
+      (props: unknown) => (
+        <Layout {...(layoutProps as LayoutProps)}>
+          <Component {...(props as any)} />
+        </Layout>
+      ),
+      extraLayouts,
+    );
+  }) as WithLayout;
+}
+
+function flattenLayouts<Props>(
+  layout: ComponentType<Props>,
+  [...layouts]: WithLayout[],
+): ComponentType<Props> {
+  const currentLayout = layouts.pop();
+  if (!currentLayout) return layout;
+  return flattenLayouts(currentLayout(layout), layouts);
+}
+
+export type WithLayout = <Props>(Component: ComponentType<Props>) => ComponentType<Props>;
+
+export const isDev =
+  process.env.NODE_ENV === "development" || (typeof __DEV__ !== "undefined" && __DEV__);

package/src/index.ts

@@ -0,0 +1,35 @@
+import { platform } from "./platform/index";
+
+export const {
+  isAndroid,
+  isBrowser,
+  isChrome,
+  isChromeExtension,
+  isClient,
+  isExpo,
+  isFirefox,
+  isFirefoxExtension,
+  isIframe,
+  isIos,
+  isNative,
+  isNext,
+  isServer,
+  isStorybook,
+  isTauri,
+  isDesktop,
+  isTouchable,
+  isWeb,
+  isWebExtension,
+  isWebTouchable,
+  isWindowDefined,
+} = platform;
+
+export * from "./platform/index";
+export * from "./helpers";
+export * from "./types";
+export * from "./config/index";
+export * from "./utils/cookie";
+export * from "./utils/downloadFile";
+export * from "./utils/clipboard";
+export * from "./utils/openUrl";
+export * from "./utils/lifecycle";

package/src/platform/index.android.ts

@@ -0,0 +1,10 @@
+import { type Platform, getBroadName, getPreciseName, platformBase } from "./platformBase";
+
+export const platform: Platform = {
+  ...platformBase,
+  isAndroid: true,
+  isExpo: true,
+  isNative: true,
+};
+platform.preciseName = getPreciseName(platform);
+platform.broadName = getBroadName(platform);

package/src/platform/index.ios.ts

@@ -0,0 +1,10 @@
+import { type Platform, getBroadName, getPreciseName, platformBase } from "./platformBase";
+
+export const platform: Platform = {
+  ...platformBase,
+  isExpo: true,
+  isIos: true,
+  isNative: true,
+};
+platform.preciseName = getPreciseName(platform);
+platform.broadName = getBroadName(platform);

package/src/platform/index.tauri.ts

@@ -0,0 +1,45 @@
+import {
+  isChrome,
+  isClient,
+  isServer,
+  isWeb,
+  isWebTouchable,
+  isWindowDefined,
+} from "@tamagui/constants";
+import { type Platform, getBroadName, getPreciseName, platformBase } from "./platformBase";
+
+declare global {
+  interface Window {
+    __TAURI_INTERNALS__?: unknown;
+    __TAURI__?: unknown;
+  }
+}
+
+const isIframe = (() => {
+  if (!isWindowDefined) return false;
+  try {
+    return window.self !== window.top;
+  } catch {
+    return true;
+  }
+})();
+
+export const platform: Platform = {
+  ...platformBase,
+  isBrowser: false,
+  isChrome,
+  isClient,
+  isIframe,
+  isServer,
+  isWeb,
+  isWebTouchable,
+  // Tauri-specific flags - using the same interface structure
+  // Platform detection: Tauri injects __TAURI_INTERNALS__ at runtime
+  isTauri: true,
+  isDesktop: true,
+};
+platform.preciseName = getPreciseName(platform);
+platform.broadName = getBroadName(platform);
+
+export type { Platform };
+export type { PlatformName } from "./platformBase";

package/src/platform/index.ts

@@ -0,0 +1,45 @@
+/// <reference types="@types/chrome" />
+/// <reference types="@types/firefox-webext-browser" />
+
+import { type Platform, getBroadName, getPreciseName, platformBase } from "./platformBase";
+
+declare global {
+  interface Window {
+    __NEXT_DATA__?: unknown;
+    ipc?: unknown;
+  }
+}
+
+const isIframe = (() => {
+  if (!platformBase.isWindowDefined) return false;
+  try {
+    return window.self !== window.top;
+  } catch {
+    return true;
+  }
+})();
+
+const isWebExtension = !!(
+  (typeof chrome !== "undefined" && !!chrome?.runtime?.id) ||
+  (typeof browser !== "undefined" && !!browser?.runtime?.id)
+);
+
+export const platform: Platform = {
+  ...platformBase,
+  isChromeExtension: typeof chrome !== "undefined" && !!chrome?.runtime?.id,
+  isFirefoxExtension: typeof browser !== "undefined" && !!browser?.runtime?.id,
+  isIframe,
+  isWebExtension,
+  isBrowser: !!(platformBase.isWeb && platformBase.isWindowDefined && !isWebExtension),
+  isNext:
+    platformBase.isWeb &&
+    (!platformBase.isWindowDefined || typeof window.__NEXT_DATA__ === "object"),
+  isFirefox:
+    platformBase.isWindowDefined &&
+    !!(window?.navigator?.userAgent?.toLowerCase().indexOf("firefox") > -1),
+};
+platform.preciseName = getPreciseName(platform);
+platform.broadName = getBroadName(platform);
+
+export type { Platform };
+export type { PlatformName } from "./platformBase";

package/src/platform/platformBase.spec.ts

@@ -0,0 +1,111 @@
+import { describe, expect, it } from "vitest";
+import { getBroadName, getPreciseName, type Platform } from "./platformBase";
+
+function makePlatform(overrides: Partial<Platform> = {}): Platform {
+  return {
+    isAndroid: false,
+    isBrowser: false,
+    isChrome: false,
+    isChromeExtension: false,
+    isClient: false,
+    isDesktop: false,
+    isExpo: false,
+    isFirefox: false,
+    isFirefoxExtension: false,
+    isIframe: false,
+    isIos: false,
+    isNative: false,
+    isNext: false,
+    isServer: false,
+    isStorybook: false,
+    isTauri: false,
+    isTouchable: false,
+    isWeb: false,
+    isWebExtension: false,
+    isWebTouchable: false,
+    isWindowDefined: false,
+    preciseName: "unknown",
+    broadName: "unknown",
+    ...overrides,
+  };
+}
+
+describe("getPreciseName", () => {
+  it('returns "unknown" when no flags are true', () => {
+    expect(getPreciseName(makePlatform())).toBe("unknown");
+  });
+
+  it("returns the first matching flag in priority order (iOS > Android > others)", () => {
+    expect(getPreciseName(makePlatform({ isIos: true, isNative: true, isClient: true }))).toBe(
+      "ios",
+    );
+  });
+
+  it('returns "android" when isAndroid is the most precise', () => {
+    expect(getPreciseName(makePlatform({ isAndroid: true, isNative: true }))).toBe("android");
+  });
+
+  it('returns "tauri" for desktop Tauri apps', () => {
+    expect(getPreciseName(makePlatform({ isTauri: true, isDesktop: true, isWeb: true }))).toBe(
+      "tauri",
+    );
+  });
+
+  it('returns "chromeExtension" over generic "chrome"', () => {
+    expect(
+      getPreciseName(makePlatform({ isChromeExtension: true, isChrome: true, isWeb: true })),
+    ).toBe("chromeExtension");
+  });
+
+  it('returns "next" for Next.js environments', () => {
+    expect(getPreciseName(makePlatform({ isNext: true, isWeb: true, isClient: true }))).toBe(
+      "next",
+    );
+  });
+
+  it('returns "chrome" for a plain Chrome browser', () => {
+    expect(getPreciseName(makePlatform({ isChrome: true, isWeb: true, isBrowser: true }))).toBe(
+      "chrome",
+    );
+  });
+
+  it('returns "server" for server-only', () => {
+    expect(getPreciseName(makePlatform({ isServer: true }))).toBe("server");
+  });
+
+  it('returns "storybook" when only isStorybook is true', () => {
+    expect(getPreciseName(makePlatform({ isStorybook: true }))).toBe("storybook");
+  });
+});
+
+describe("getBroadName", () => {
+  it('returns "unknown" when no flags are true', () => {
+    expect(getBroadName(makePlatform())).toBe("unknown");
+  });
+
+  it("returns the last matching flag in reverse priority order (broadest)", () => {
+    expect(getBroadName(makePlatform({ isIos: true, isNative: true, isClient: true }))).toBe(
+      "client",
+    );
+  });
+
+  it('returns "server" (broadest) for a server environment', () => {
+    expect(getBroadName(makePlatform({ isNext: true, isWeb: true, isServer: true }))).toBe(
+      "server",
+    );
+  });
+
+  it('returns "storybook" for storybook-only', () => {
+    expect(getBroadName(makePlatform({ isStorybook: true }))).toBe("storybook");
+  });
+
+  it('returns "iframe" when iframe + storybook are set', () => {
+    expect(getBroadName(makePlatform({ isStorybook: true, isIframe: true }))).toBe("storybook");
+  });
+
+  it('returns "browser" for a typical browser client', () => {
+    expect(
+      getBroadName(makePlatform({ isChrome: true, isWeb: true, isBrowser: true, isClient: true })),
+    ).toBe("client");
+  });
+});

package/src/platform/platformBase.ts

@@ -0,0 +1,129 @@
+import {
+  isChrome,
+  isClient,
+  isServer,
+  isTouchable,
+  isWeb,
+  isWebTouchable,
+  isWindowDefined,
+} from "@tamagui/constants";
+
+declare global {
+  interface Window {
+    __STORYBOOK_ADDONS_PREVIEW: unknown;
+  }
+}
+
+const platformOrder = [
+  "Ios",
+  "Android",
+  "Native",
+  "Tauri",
+  "Desktop",
+  "ChromeExtension",
+  "FirefoxExtension",
+  "WebExtension",
+  "Next",
+  "Expo",
+  "Chrome",
+  "Firefox",
+  "Web",
+  "Browser",
+  "Client",
+  "Server",
+  "Iframe",
+  "Storybook",
+];
+
+export type PlatformName =
+  | "ios"
+  | "android"
+  | "native"
+  | "tauri"
+  | "desktop"
+  | "chromeExtension"
+  | "firefoxExtension"
+  | "webExtension"
+  | "next"
+  | "expo"
+  | "chrome"
+  | "firefox"
+  | "web"
+  | "browser"
+  | "client"
+  | "server"
+  | "iframe"
+  | "storybook"
+  | "unknown";
+
+export const platformBase = {
+  isAndroid: false,
+  isBrowser: false,
+  isChrome,
+  isChromeExtension: false,
+  isClient,
+  isDesktop: false,
+  isExpo: false,
+  isFirefox: false,
+  isFirefoxExtension: false,
+  isIframe: false,
+  isIos: false,
+  isNative: false,
+  isNext: false,
+  isServer,
+  isStorybook: isWindowDefined && typeof window.__STORYBOOK_ADDONS_PREVIEW === "object",
+  isTauri: false,
+  isTouchable,
+  isWeb,
+  isWebExtension: false,
+  isWebTouchable,
+  isWindowDefined,
+  preciseName: "unknown",
+  broadName: "unknown",
+} as const;
+
+export function getPreciseName(platform: Omit<Platform, "preciseName">) {
+  const flags = platform as unknown as Record<string, boolean>;
+  for (const name of platformOrder) {
+    if (flags[`is${name}`]) {
+      return `${name[0].toLowerCase()}${name.slice(1)}` as PlatformName;
+    }
+  }
+  return "unknown";
+}
+
+export function getBroadName(platform: Omit<Platform, "broadName">) {
+  const flags = platform as unknown as Record<string, boolean>;
+  for (const name of platformOrder.slice().reverse()) {
+    if (flags[`is${name}`]) {
+      return `${name[0].toLowerCase()}${name.slice(1)}` as PlatformName;
+    }
+  }
+  return "unknown";
+}
+
+export interface Platform {
+  isAndroid: boolean;
+  isBrowser: boolean;
+  isChrome: boolean;
+  isChromeExtension: boolean;
+  isClient: boolean;
+  isDesktop: boolean;
+  isExpo: boolean;
+  isFirefox: boolean;
+  isFirefoxExtension: boolean;
+  isIframe: boolean;
+  isIos: boolean;
+  isNative: boolean;
+  isNext: boolean;
+  isServer: boolean;
+  isStorybook: boolean;
+  isTauri: boolean;
+  isTouchable: boolean;
+  isWeb: boolean;
+  isWebExtension: boolean;
+  isWebTouchable: boolean;
+  isWindowDefined: boolean;
+  broadName: PlatformName;
+  preciseName: PlatformName;
+}

package/src/rnw_overrides.d.ts

@@ -0,0 +1,35 @@
+/**
+ * React Native Web type augmentations for PressableStateCallbackType, ViewStyle,
+ * TextProps, ViewProps. Include via tsconfig types: "@multiplatform.one/platform/rnw-overrides"
+ */
+
+import type { MouseEvent } from "react";
+
+declare module "react-native" {
+  interface PressableStateCallbackType {
+    hovered?: boolean;
+    focused?: boolean;
+  }
+  interface ViewStyle {
+    transitionProperty?: string;
+    transitionDuration?: string;
+  }
+  interface TextProps {
+    accessibilityComponentType?: never;
+    accessibilityTraits?: never;
+    href?: string;
+    hrefAttrs?: {
+      rel: "noreferrer";
+      target?: "_blank";
+    };
+  }
+  interface ViewProps {
+    accessibilityRole?: string;
+    href?: string;
+    hrefAttrs?: {
+      rel: "noreferrer";
+      target?: "_blank";
+    };
+    onClick?: (e: MouseEvent<HTMLAnchorElement, MouseEvent>) => void;
+  }
+}

package/src/types.ts

@@ -0,0 +1,3 @@
+import type { StyleProp as RNStyleProp } from "react-native";
+
+export type StyleProp = RNStyleProp<any>;

package/src/utils/clipboard.native.ts

@@ -0,0 +1,3 @@
+export async function writeToClipboard(_text: string): Promise<boolean> {
+  return false;
+}

package/src/utils/clipboard.spec.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import { writeToClipboard } from "./clipboard";
+
+describe("writeToClipboard", () => {
+  beforeEach(() => {
+    vi.stubGlobal("navigator", {
+      clipboard: { writeText: vi.fn().mockResolvedValue(undefined) },
+    });
+  });
+
+  it("returns true when clipboard write succeeds", async () => {
+    expect(await writeToClipboard("hello")).toBe(true);
+    expect(navigator.clipboard.writeText).toHaveBeenCalledWith("hello");
+  });
+
+  it("returns false when clipboard write fails", async () => {
+    vi.stubGlobal("navigator", {
+      clipboard: {
+        writeText: vi.fn().mockRejectedValue(new Error("denied")),
+      },
+    });
+    expect(await writeToClipboard("hello")).toBe(false);
+  });
+});

package/src/utils/clipboard.ts

@@ -0,0 +1,8 @@
+export async function writeToClipboard(text: string): Promise<boolean> {
+  try {
+    await navigator.clipboard.writeText(text);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/utils/cookie.native.ts

@@ -0,0 +1,13 @@
+const store = new Map<string, string>();
+
+export function getCookie(name: string): string | null {
+  return store.get(name) ?? null;
+}
+
+export function setCookie(name: string, value: string, _options?: object): void {
+  store.set(name, value);
+}
+
+export function deleteCookie(name: string, _path?: string): void {
+  store.delete(name);
+}

package/src/utils/cookie.spec.ts

@@ -0,0 +1,92 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { deleteCookie, getCookie, setCookie } from "./cookie";
+
+describe("cookie utilities", () => {
+  beforeEach(() => {
+    Object.defineProperty(document, "cookie", {
+      writable: true,
+      value: "",
+    });
+  });
+
+  afterEach(() => {
+    Object.defineProperty(document, "cookie", {
+      writable: true,
+      value: "",
+    });
+  });
+
+  describe("getCookie", () => {
+    it("returns null when no cookies are set", () => {
+      expect(getCookie("missing")).toBeNull();
+    });
+
+    it("returns the value of an existing cookie", () => {
+      document.cookie = "theme=dark";
+      expect(getCookie("theme")).toBe("dark");
+    });
+
+    it("handles URL-encoded values", () => {
+      document.cookie = "data=hello%20world";
+      expect(getCookie("data")).toBe("hello world");
+    });
+
+    it("returns the correct cookie among multiple", () => {
+      document.cookie = "a=1; b=2; c=3";
+      expect(getCookie("b")).toBe("2");
+    });
+
+    it("escapes regex special characters in cookie names", () => {
+      document.cookie = "weird.name[0]=value";
+      expect(getCookie("weird.name[0]")).toBe("value");
+    });
+
+    it("returns null for a partial name match", () => {
+      document.cookie = "prefix_key=value";
+      expect(getCookie("key")).toBeNull();
+    });
+  });
+
+  describe("setCookie", () => {
+    it("sets a basic cookie with default options", () => {
+      setCookie("key", "value");
+      expect(document.cookie).toContain("key=value");
+      expect(document.cookie).toContain("path=/");
+      expect(document.cookie).toContain("SameSite=Lax");
+    });
+
+    it("sets a cookie with expiration days", () => {
+      setCookie("session", "abc", { days: 7 });
+      expect(document.cookie).toContain("session=abc");
+      expect(document.cookie).toContain("expires=");
+    });
+
+    it("sets the Secure flag when specified", () => {
+      setCookie("secure_key", "val", { secure: true });
+      expect(document.cookie).toContain("Secure");
+    });
+
+    it("sets custom SameSite value", () => {
+      setCookie("strict_key", "val", { sameSite: "Strict" });
+      expect(document.cookie).toContain("SameSite=Strict");
+    });
+
+    it("URL-encodes name and value", () => {
+      setCookie("special key", "value with spaces");
+      expect(document.cookie).toContain("special%20key=value%20with%20spaces");
+    });
+  });
+
+  describe("deleteCookie", () => {
+    it("sets the cookie to expire in the past", () => {
+      setCookie("to_delete", "value");
+      deleteCookie("to_delete");
+      expect(document.cookie).toContain("expires=Thu, 01 Jan 1970");
+    });
+
+    it("uses a custom path", () => {
+      deleteCookie("key", "/custom");
+      expect(document.cookie).toContain("path=/custom");
+    });
+  });
+});

package/src/utils/cookie.ts

@@ -0,0 +1,33 @@
+export function getCookie(name: string): string | null {
+  if (typeof document === "undefined") return null;
+  const match = document.cookie.match(
+    new RegExp("(?:^|; )" + name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") + "=([^;]*)"),
+  );
+  return match ? decodeURIComponent(match[1]) : null;
+}
+
+export function setCookie(
+  name: string,
+  value: string,
+  options: {
+    days?: number;
+    path?: string;
+    sameSite?: "Strict" | "Lax" | "None";
+    secure?: boolean;
+  } = {},
+): void {
+  if (typeof document === "undefined") return;
+  const { days, path = "/", sameSite = "Lax", secure = false } = options;
+  let cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}; path=${path}; SameSite=${sameSite}`;
+  if (days != null) {
+    const expires = new Date(Date.now() + days * 864e5);
+    cookie += `; expires=${expires.toUTCString()}`;
+  }
+  if (secure) cookie += "; Secure";
+  document.cookie = cookie;
+}
+
+export function deleteCookie(name: string, path = "/"): void {
+  if (typeof document === "undefined") return;
+  document.cookie = `${encodeURIComponent(name)}=; path=${path}; expires=Thu, 01 Jan 1970 00:00:00 GMT`;
+}

package/src/utils/downloadFile.native.ts

@@ -0,0 +1,7 @@
+export function downloadFile(_url: string, _filename: string): void {
+  console.warn("downloadFile: not supported on native");
+}
+
+export function downloadBlob(_blob: Blob, _filename: string): void {
+  console.warn("downloadBlob: not supported on native");
+}