shipos 0.1.0

package/dist/modules/feature-flags.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Feature Flags Module
+ *
+ * Provides namespaced access to feature flag operations.
+ *
+ * @example
+ * ```typescript
+ * const flags = await shipos.featureFlags.getAll();
+ * const isEnabled = await shipos.featureFlags.get('new-feature', false);
+ * ```
+ */
+import type { Cache } from "../cache";
+import type { FlagsResponse } from "../types";
+/**
+ * Internal context shared by the parent ShipOS client
+ */
+export interface FeatureFlagsContext {
+    request: <T>(endpoint: string, options?: {
+        method?: string;
+        body?: unknown;
+    }) => Promise<T>;
+    cache: Cache;
+    getEnvironment: () => string;
+    log: (...args: unknown[]) => void;
+}
+export declare class FeatureFlagsModule {
+    private ctx;
+    constructor(ctx: FeatureFlagsContext);
+    /**
+     * Get all feature flags
+     *
+     * @returns Record of flag keys to boolean values
+     *
+     * @example
+     * ```typescript
+     * const flags = await shipos.featureFlags.getAll();
+     * // => { "new-dashboard": true, "beta-features": false }
+     * ```
+     */
+    getAll(): Promise<FlagsResponse>;
+    /**
+     * Get a single feature flag value
+     *
+     * @param key - The flag key
+     * @param defaultValue - Default value if flag is not found (defaults to false)
+     * @returns The flag value or default
+     *
+     * @example
+     * ```typescript
+     * const isEnabled = await shipos.featureFlags.get('new-dashboard', false);
+     * ```
+     */
+    get(key: string, defaultValue?: boolean): Promise<boolean>;
+    /**
+     * Refresh flags (bypass cache)
+     *
+     * @returns Fresh flags from the API
+     *
+     * @example
+     * ```typescript
+     * const freshFlags = await shipos.featureFlags.refresh();
+     * ```
+     */
+    refresh(): Promise<FlagsResponse>;
+}
+//# sourceMappingURL=feature-flags.d.ts.map

package/dist/modules/feature-flags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-flags.d.ts","sourceRoot":"","sources":["../../src/modules/feature-flags.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACtC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;IAC5F,KAAK,EAAE,KAAK,CAAC;IACb,cAAc,EAAE,MAAM,MAAM,CAAC;IAC7B,GAAG,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;CACnC;AAED,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,GAAG,CAAsB;gBAErB,GAAG,EAAE,mBAAmB;IAIpC;;;;;;;;;;OAUG;IACG,MAAM,IAAI,OAAO,CAAC,aAAa,CAAC;IActC;;;;;;;;;;;OAWG;IACG,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,YAAY,GAAE,OAAe,GAAG,OAAO,CAAC,OAAO,CAAC;IAKvE;;;;;;;;;OASG;IACG,OAAO,IAAI,OAAO,CAAC,aAAa,CAAC;CAKxC"}

package/dist/react/components.d.ts

@@ -0,0 +1,85 @@
+import type { ReactNode } from "react";
+/**
+ * Feature Component Props
+ */
+interface FeatureProps {
+    /** The feature flag key */
+    flag: string;
+    /** Content to render when the flag is enabled */
+    children: ReactNode;
+    /** Content to render when the flag is disabled (optional) */
+    fallback?: ReactNode;
+    /** Content to render while loading (optional) */
+    loading?: ReactNode;
+}
+/**
+ * Feature Component
+ *
+ * Conditionally renders content based on a feature flag.
+ *
+ * @example
+ * ```tsx
+ * // Basic usage
+ * <Feature flag="new-dashboard">
+ *   <NewDashboard />
+ * </Feature>
+ *
+ * // With fallback
+ * <Feature flag="new-dashboard" fallback={<OldDashboard />}>
+ *   <NewDashboard />
+ * </Feature>
+ *
+ * // With loading state
+ * <Feature flag="new-dashboard" loading={<Skeleton />}>
+ *   <NewDashboard />
+ * </Feature>
+ * ```
+ */
+export declare function Feature({ flag, children, fallback, loading, }: FeatureProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * FeatureEnabled Component Props
+ */
+interface FeatureEnabledProps {
+    /** The feature flag key */
+    flag: string;
+    /** Content to render when the flag is enabled */
+    children: ReactNode;
+}
+/**
+ * FeatureEnabled Component
+ *
+ * Only renders children when the flag is enabled.
+ * Simpler alternative to Feature when you don't need fallback.
+ *
+ * @example
+ * ```tsx
+ * <FeatureEnabled flag="beta-features">
+ *   <BetaBanner />
+ * </FeatureEnabled>
+ * ```
+ */
+export declare function FeatureEnabled({ flag, children }: FeatureEnabledProps): import("react/jsx-runtime").JSX.Element | null;
+/**
+ * FeatureDisabled Component Props
+ */
+interface FeatureDisabledProps {
+    /** The feature flag key */
+    flag: string;
+    /** Content to render when the flag is disabled */
+    children: ReactNode;
+}
+/**
+ * FeatureDisabled Component
+ *
+ * Only renders children when the flag is disabled.
+ *
+ * @example
+ * ```tsx
+ * <FeatureDisabled flag="maintenance-mode">
+ *   <MainContent />
+ * </FeatureDisabled>
+ * ```
+ */
+export declare function FeatureDisabled({ flag, children }: FeatureDisabledProps): import("react/jsx-runtime").JSX.Element | null;
+export {};
+//# sourceMappingURL=components.d.ts.map

package/dist/react/components.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"components.d.ts","sourceRoot":"","sources":["../../src/react/components.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAGvC;;GAEG;AACH,UAAU,YAAY;IACpB,2BAA2B;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,iDAAiD;IACjD,QAAQ,EAAE,SAAS,CAAC;IACpB,6DAA6D;IAC7D,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,iDAAiD;IACjD,OAAO,CAAC,EAAE,SAAS,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,OAAO,CAAC,EACtB,IAAI,EACJ,QAAQ,EACR,QAAe,EACf,OAAc,GACf,EAAE,YAAY,2CAQd;AAED;;GAEG;AACH,UAAU,mBAAmB;IAC3B,2BAA2B;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,iDAAiD;IACjD,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,mBAAmB,kDAQrE;AAED;;GAEG;AACH,UAAU,oBAAoB;IAC5B,2BAA2B;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,kDAAkD;IAClD,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,oBAAoB,kDAQvE"}

package/dist/react/hooks.d.ts

@@ -0,0 +1,115 @@
+import type { CustomerInfo, SignInOptions } from "../types";
+/**
+ * Hook to get all feature flags
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { flags, isLoading, error } = useFlags();
+ *
+ *   if (isLoading) return <div>Loading...</div>;
+ *   if (error) return <div>Error: {error.message}</div>;
+ *
+ *   return (
+ *     <div>
+ *       {flags['new-feature'] && <NewFeature />}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useFlags(): {
+    flags: import("..").FlagsResponse;
+    isLoading: boolean;
+    error: Error | null;
+    refreshFlags: () => Promise<void>;
+};
+/**
+ * Hook to get a single feature flag
+ *
+ * @param key - The flag key
+ * @param defaultValue - Default value if flag is not found
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { enabled, isLoading } = useFlag('new-feature', false);
+ *
+ *   if (isLoading) return <div>Loading...</div>;
+ *
+ *   return enabled ? <NewFeature /> : <OldFeature />;
+ * }
+ * ```
+ */
+export declare function useFlag(key: string, defaultValue?: boolean): {
+    enabled: boolean;
+    isLoading: boolean;
+    error: Error | null;
+};
+/**
+ * Hook to get a configuration by slug
+ *
+ * @param slug - The config slug
+ *
+ * @example
+ * ```tsx
+ * interface PricingConfig {
+ *   plans: Array<{ name: string; price: number }>;
+ * }
+ *
+ * function PricingPage() {
+ *   const { config, isLoading, error, refresh } = useConfig<PricingConfig>('pricing');
+ *
+ *   if (isLoading) return <div>Loading...</div>;
+ *   if (error) return <div>Error: {error.message}</div>;
+ *
+ *   return (
+ *     <div>
+ *       {config?.plans.map(plan => (
+ *         <div key={plan.name}>{plan.name}: ${plan.price}</div>
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useConfig<T = Record<string, unknown>>(slug: string): {
+    config: T | null;
+    isLoading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+};
+/**
+ * Hook to manage customer identification
+ *
+ * @example
+ * ```tsx
+ * function UserProfile() {
+ *   const { customer, signIn, signOut } = useCustomer();
+ *
+ *   useEffect(() => {
+ *     // Sign in when user is authenticated
+ *     signIn({ externalId: 'user-123', metadata: { plan: 'pro' } });
+ *   }, []);
+ *
+ *   return (
+ *     <div>
+ *       {customer ? (
+ *         <>
+ *           <p>Signed in as: {customer.externalId}</p>
+ *           <button onClick={signOut}>Sign Out</button>
+ *         </>
+ *       ) : (
+ *         <p>Not signed in</p>
+ *       )}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useCustomer(): {
+    customer: CustomerInfo | null;
+    signIn: (options: SignInOptions) => Promise<CustomerInfo>;
+    signOut: () => void;
+};
+//# sourceMappingURL=hooks.d.ts.map

package/dist/react/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../src/react/hooks.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAkB,YAAY,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE5E;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,QAAQ;;;;;EAGvB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,YAAY,GAAE,OAAe;;;;EAKjE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,SAAS,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM;;;;;EA0ClE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,WAAW,IAUpB;IACH,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAC;IAC9B,MAAM,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;IAC1D,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB,CACF"}

package/dist/react/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * ShipOS SDK React Integration
+ *
+ * React hooks and components for ShipOS feature flags, configs, and customer identification.
+ *
+ * @example
+ * ```tsx
+ * import { ShipOSProvider, useFlag, useCustomer, Feature } from '@shipos/sdk/react';
+ *
+ * function App() {
+ *   return (
+ *     <ShipOSProvider config={{ apiKey: 'your-api-key' }}>
+ *       <Feature flag="new-feature">
+ *         <NewFeature />
+ *       </Feature>
+ *     </ShipOSProvider>
+ *   );
+ * }
+ * ```
+ */
+export { ShipOSProvider, useShipOS } from "./provider";
+export { useFlags, useFlag, useConfig, useCustomer } from "./hooks";
+export { Feature, FeatureEnabled, FeatureDisabled } from "./components";
+export type { ShipOSConfig, FlagsResponse, ConfigResponse, CustomerInfo, SignInOptions, } from "../types";
+//# sourceMappingURL=index.d.ts.map

package/dist/react/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/react/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAGvD,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAGpE,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAGxE,YAAY,EACV,YAAY,EACZ,aAAa,EACb,cAAc,EACd,YAAY,EACZ,aAAa,GACd,MAAM,UAAU,CAAC"}

package/dist/react/index.js

@@ -0,0 +1,388 @@
+// src/cache.ts
+class Cache {
+  store = new Map;
+  defaultTTL;
+  constructor(defaultTTL = 60000) {
+    this.defaultTTL = defaultTTL;
+  }
+  get(key) {
+    const entry = this.store.get(key);
+    if (!entry) {
+      return null;
+    }
+    if (Date.now() - entry.timestamp > this.defaultTTL) {
+      this.store.delete(key);
+      return null;
+    }
+    return entry.data;
+  }
+  set(key, data) {
+    this.store.set(key, {
+      data,
+      timestamp: Date.now()
+    });
+  }
+  delete(key) {
+    this.store.delete(key);
+  }
+  clear() {
+    this.store.clear();
+  }
+  setTTL(ttl) {
+    this.defaultTTL = ttl;
+  }
+}
+
+// src/modules/feature-flags.ts
+class FeatureFlagsModule {
+  ctx;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async getAll() {
+    const cacheKey = `flags:${this.ctx.getEnvironment()}`;
+    const cached = this.ctx.cache.get(cacheKey);
+    if (cached) {
+      this.ctx.log("Returning cached flags");
+      return cached;
+    }
+    const flags = await this.ctx.request("/v1/flags");
+    this.ctx.cache.set(cacheKey, flags);
+    return flags;
+  }
+  async get(key, defaultValue = false) {
+    const flags = await this.getAll();
+    return flags[key] ?? defaultValue;
+  }
+  async refresh() {
+    const cacheKey = `flags:${this.ctx.getEnvironment()}`;
+    this.ctx.cache.delete(cacheKey);
+    return this.getAll();
+  }
+}
+
+// src/modules/configs.ts
+class ConfigsModule {
+  ctx;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async get(slug) {
+    const cacheKey = `config:${this.ctx.getEnvironment()}:${slug}`;
+    const cached = this.ctx.cache.get(cacheKey);
+    if (cached) {
+      this.ctx.log(`Returning cached config: ${slug}`);
+      return cached;
+    }
+    const config = await this.ctx.request(`/v1/config/${slug}`);
+    this.ctx.cache.set(cacheKey, config);
+    return config;
+  }
+  async refresh(slug) {
+    const cacheKey = `config:${this.ctx.getEnvironment()}:${slug}`;
+    this.ctx.cache.delete(cacheKey);
+    return this.get(slug);
+  }
+}
+
+// src/modules/customers.ts
+class CustomersModule {
+  ctx;
+  customer = null;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async signIn(options) {
+    if (!options.externalId) {
+      throw new Error("ShipOS: externalId is required for signIn");
+    }
+    this.ctx.log(`Signing in customer: ${options.externalId}`);
+    this.customer = {
+      externalId: options.externalId,
+      metadata: options.metadata
+    };
+    this.ctx.setCustomerId(options.externalId);
+    await this.ctx.request("/v1/customers/identify", {
+      method: "POST",
+      body: {
+        externalId: options.externalId,
+        metadata: options.metadata ?? {}
+      }
+    });
+    this.ctx.log(`Customer signed in: ${options.externalId}`);
+    return this.customer;
+  }
+  signOut() {
+    this.ctx.log("Signing out customer");
+    this.customer = null;
+    this.ctx.setCustomerId(null);
+  }
+  get() {
+    return this.customer;
+  }
+}
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.shipos.app";
+var DEFAULT_CACHE_TTL = 60000;
+var SDK_VERSION = "0.1.0";
+
+class ShipOS {
+  apiKey;
+  baseUrl;
+  environment;
+  cache;
+  debug;
+  customerId = null;
+  featureFlags;
+  configs;
+  customers;
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new Error("ShipOS: apiKey is required");
+    }
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
+    this.environment = config.environment || "production";
+    this.cache = new Cache(config.cacheTTL || DEFAULT_CACHE_TTL);
+    this.debug = config.debug || false;
+    const ctx = {
+      request: this.request.bind(this),
+      cache: this.cache,
+      getEnvironment: this.getEnvironment.bind(this),
+      log: this.log.bind(this),
+      setCustomerId: (id) => {
+        this.customerId = id;
+      }
+    };
+    this.featureFlags = new FeatureFlagsModule(ctx);
+    this.configs = new ConfigsModule(ctx);
+    this.customers = new CustomersModule(ctx);
+  }
+  log(...args) {
+    if (this.debug) {
+      console.log("[ShipOS]", ...args);
+    }
+  }
+  async request(endpoint, options = {}) {
+    const url = `${this.baseUrl}${endpoint}`;
+    const method = options.method || "GET";
+    this.log(`${method} ${url}`);
+    const headers = {
+      "x-shipos-key": this.apiKey,
+      "x-shipos-env": this.environment,
+      "x-shipos-sdk-version": SDK_VERSION,
+      "Content-Type": "application/json"
+    };
+    if (this.customerId) {
+      headers["x-shipos-customer-id"] = this.customerId;
+    }
+    const fetchOptions = { method, headers };
+    if (options.body && method !== "GET") {
+      fetchOptions.body = JSON.stringify(options.body);
+    }
+    const response = await fetch(url, fetchOptions);
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({
+        error: `HTTP ${response.status}`,
+        code: "HTTP_ERROR"
+      }));
+      throw new Error(error.error || `Request failed: ${response.status}`);
+    }
+    return response.json();
+  }
+  clearCache() {
+    this.cache.clear();
+    this.log("Cache cleared");
+  }
+  setEnvironment(environment) {
+    this.environment = environment;
+    this.cache.clear();
+    this.log(`Environment changed to: ${environment}`);
+  }
+  getEnvironment() {
+    return this.environment;
+  }
+}
+function createShipOS(config) {
+  return new ShipOS(config);
+}
+// src/react/provider.tsx
+import {
+  createContext,
+  useContext,
+  useState,
+  useEffect,
+  useCallback
+} from "react";
+import { jsxDEV } from "react/jsx-dev-runtime";
+"use client";
+var ShipOSContext = createContext(null);
+function ShipOSProvider({
+  config,
+  children,
+  initialFlags = {}
+}) {
+  const [client] = useState(() => new ShipOS(config));
+  const [flags, setFlags] = useState(initialFlags);
+  const [isLoading, setIsLoading] = useState(Object.keys(initialFlags).length === 0);
+  const [error, setError] = useState(null);
+  const [customer, setCustomer] = useState(null);
+  const fetchFlags = useCallback(async () => {
+    try {
+      setIsLoading(true);
+      setError(null);
+      const newFlags = await client.featureFlags.getAll();
+      setFlags(newFlags);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch flags"));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const refreshFlags = useCallback(async () => {
+    try {
+      setError(null);
+      const newFlags = await client.featureFlags.refresh();
+      setFlags(newFlags);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to refresh flags"));
+    }
+  }, [client]);
+  const signIn = useCallback(async (options) => {
+    const customerInfo = await client.customers.signIn(options);
+    setCustomer(customerInfo);
+    return customerInfo;
+  }, [client]);
+  const signOut = useCallback(() => {
+    client.customers.signOut();
+    setCustomer(null);
+  }, [client]);
+  useEffect(() => {
+    if (Object.keys(initialFlags).length === 0) {
+      fetchFlags();
+    }
+  }, [fetchFlags, initialFlags]);
+  const value = {
+    client,
+    flags,
+    isLoading,
+    error,
+    refreshFlags,
+    customer,
+    signIn,
+    signOut
+  };
+  return /* @__PURE__ */ jsxDEV(ShipOSContext.Provider, {
+    value,
+    children
+  }, undefined, false, undefined, this);
+}
+function useShipOS() {
+  const context = useContext(ShipOSContext);
+  if (!context) {
+    throw new Error("useShipOS must be used within a ShipOSProvider");
+  }
+  return context;
+}
+// src/react/hooks.ts
+import { useState as useState2, useEffect as useEffect2, useCallback as useCallback2 } from "react";
+"use client";
+function useFlags() {
+  const { flags, isLoading, error, refreshFlags } = useShipOS();
+  return { flags, isLoading, error, refreshFlags };
+}
+function useFlag(key, defaultValue = false) {
+  const { flags, isLoading, error } = useShipOS();
+  const enabled = flags[key] ?? defaultValue;
+  return { enabled, isLoading, error };
+}
+function useConfig(slug) {
+  const { client } = useShipOS();
+  const [config, setConfig] = useState2(null);
+  const [isLoading, setIsLoading] = useState2(true);
+  const [error, setError] = useState2(null);
+  const fetchConfig = useCallback2(async () => {
+    try {
+      setIsLoading(true);
+      setError(null);
+      const data = await client.configs.get(slug);
+      setConfig(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(`Failed to fetch config: ${slug}`));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client, slug]);
+  const refresh = useCallback2(async () => {
+    try {
+      setError(null);
+      const data = await client.configs.refresh(slug);
+      setConfig(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(`Failed to refresh config: ${slug}`));
+    }
+  }, [client, slug]);
+  useEffect2(() => {
+    fetchConfig();
+  }, [fetchConfig]);
+  return { config, isLoading, error, refresh };
+}
+function useCustomer() {
+  const { customer, signIn, signOut } = useShipOS();
+  return {
+    customer,
+    signIn,
+    signOut
+  };
+}
+// src/react/components.tsx
+import { jsxDEV as jsxDEV2, Fragment } from "react/jsx-dev-runtime";
+"use client";
+function Feature({
+  flag,
+  children,
+  fallback = null,
+  loading = null
+}) {
+  const { enabled, isLoading } = useFlag(flag);
+  if (isLoading && loading) {
+    return /* @__PURE__ */ jsxDEV2(Fragment, {
+      children: loading
+    }, undefined, false, undefined, this);
+  }
+  return enabled ? /* @__PURE__ */ jsxDEV2(Fragment, {
+    children
+  }, undefined, false, undefined, this) : /* @__PURE__ */ jsxDEV2(Fragment, {
+    children: fallback
+  }, undefined, false, undefined, this);
+}
+function FeatureEnabled({ flag, children }) {
+  const { enabled, isLoading } = useFlag(flag);
+  if (isLoading || !enabled) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxDEV2(Fragment, {
+    children
+  }, undefined, false, undefined, this);
+}
+function FeatureDisabled({ flag, children }) {
+  const { enabled, isLoading } = useFlag(flag);
+  if (isLoading || enabled) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxDEV2(Fragment, {
+    children
+  }, undefined, false, undefined, this);
+}
+export {
+  useShipOS,
+  useFlags,
+  useFlag,
+  useCustomer,
+  useConfig,
+  ShipOSProvider,
+  FeatureEnabled,
+  FeatureDisabled,
+  Feature
+};