@iota-uz/sdk 0.1.2 → 0.3.1

package/dist/index-B73-BCi-.d.cts

@@ -0,0 +1,84 @@
+/**
+ * TypeScript type definitions for IOTA SDK Applet Core
+ * Matches Go backend types from pkg/applet/types.go
+ */
+interface InitialContext {
+    user: UserContext;
+    tenant: TenantContext;
+    locale: LocaleContext;
+    config: AppConfig;
+    route: RouteContext;
+    session: SessionContext;
+    error: ErrorContext | null;
+    extensions?: Record<string, unknown>;
+}
+interface UserContext {
+    id: number;
+    email: string;
+    firstName: string;
+    lastName: string;
+    permissions: string[];
+}
+interface TenantContext {
+    id: string;
+    name: string;
+}
+interface LocaleContext {
+    language: string;
+    translations: Record<string, string>;
+}
+interface AppConfig {
+    graphQLEndpoint?: string;
+    streamEndpoint?: string;
+    restEndpoint?: string;
+    basePath?: string;
+    assetsBasePath?: string;
+    rpcUIEndpoint?: string;
+    shellMode?: 'embedded' | 'standalone';
+}
+interface RouteContext {
+    path: string;
+    params: Record<string, string>;
+    query: Record<string, string>;
+}
+interface SessionContext {
+    expiresAt: number;
+    refreshURL: string;
+    csrfToken: string;
+}
+interface ErrorContext {
+    supportEmail?: string;
+    debugMode: boolean;
+    errorCodes?: Record<string, string>;
+    retryConfig?: RetryConfig;
+}
+interface RetryConfig {
+    maxAttempts: number;
+    backoffMs: number;
+}
+/**
+ * Hook return types
+ */
+interface TranslationHook {
+    t: (key: string, params?: Record<string, unknown>) => string;
+    language: string;
+}
+interface PermissionsHook {
+    hasPermission: (permission: string) => boolean;
+    hasAnyPermission: (...permissions: string[]) => boolean;
+    permissions: string[];
+}
+interface SessionHook {
+    isExpiringSoon: boolean;
+    refreshSession: () => Promise<void>;
+    csrfToken: string;
+    expiresAt: number;
+}
+interface StreamingHook {
+    isStreaming: boolean;
+    processStream: <T>(generator: AsyncGenerator<T>, onChunk: (chunk: T) => void, signal?: AbortSignal) => Promise<void>;
+    cancel: () => void;
+    reset: () => void;
+}
+
+export type { AppConfig as A, InitialContext as I, LocaleContext as L, PermissionsHook as P, RouteContext as R, SessionHook as S, TranslationHook as T, UserContext as U, StreamingHook as a, SessionContext as b, TenantContext as c };

package/dist/index-B73-BCi-.d.ts

@@ -0,0 +1,84 @@
+/**
+ * TypeScript type definitions for IOTA SDK Applet Core
+ * Matches Go backend types from pkg/applet/types.go
+ */
+interface InitialContext {
+    user: UserContext;
+    tenant: TenantContext;
+    locale: LocaleContext;
+    config: AppConfig;
+    route: RouteContext;
+    session: SessionContext;
+    error: ErrorContext | null;
+    extensions?: Record<string, unknown>;
+}
+interface UserContext {
+    id: number;
+    email: string;
+    firstName: string;
+    lastName: string;
+    permissions: string[];
+}
+interface TenantContext {
+    id: string;
+    name: string;
+}
+interface LocaleContext {
+    language: string;
+    translations: Record<string, string>;
+}
+interface AppConfig {
+    graphQLEndpoint?: string;
+    streamEndpoint?: string;
+    restEndpoint?: string;
+    basePath?: string;
+    assetsBasePath?: string;
+    rpcUIEndpoint?: string;
+    shellMode?: 'embedded' | 'standalone';
+}
+interface RouteContext {
+    path: string;
+    params: Record<string, string>;
+    query: Record<string, string>;
+}
+interface SessionContext {
+    expiresAt: number;
+    refreshURL: string;
+    csrfToken: string;
+}
+interface ErrorContext {
+    supportEmail?: string;
+    debugMode: boolean;
+    errorCodes?: Record<string, string>;
+    retryConfig?: RetryConfig;
+}
+interface RetryConfig {
+    maxAttempts: number;
+    backoffMs: number;
+}
+/**
+ * Hook return types
+ */
+interface TranslationHook {
+    t: (key: string, params?: Record<string, unknown>) => string;
+    language: string;
+}
+interface PermissionsHook {
+    hasPermission: (permission: string) => boolean;
+    hasAnyPermission: (...permissions: string[]) => boolean;
+    permissions: string[];
+}
+interface SessionHook {
+    isExpiringSoon: boolean;
+    refreshSession: () => Promise<void>;
+    csrfToken: string;
+    expiresAt: number;
+}
+interface StreamingHook {
+    isStreaming: boolean;
+    processStream: <T>(generator: AsyncGenerator<T>, onChunk: (chunk: T) => void, signal?: AbortSignal) => Promise<void>;
+    cancel: () => void;
+    reset: () => void;
+}
+
+export type { AppConfig as A, InitialContext as I, LocaleContext as L, PermissionsHook as P, RouteContext as R, SessionHook as S, TranslationHook as T, UserContext as U, StreamingHook as a, SessionContext as b, TenantContext as c };

package/dist/index.cjs

@@ -2,6 +2,7 @@
 
 var react = require('react');
 var jsxRuntime = require('react/jsx-runtime');
+var client = require('react-dom/client');
 
 // ui/src/applet-core/context/AppletContext.tsx
 var AppletContext = react.createContext(null);
@@ -175,10 +176,356 @@ function useStreaming() {
   };
 }
 
+// ui/src/applet-core/hooks/useAppletRuntime.ts
+function useAppletRuntime() {
+  const config = useConfig();
+  const basePath = config.basePath ?? "";
+  const normalizedBasePath = basePath.endsWith("/") ? basePath.slice(0, -1) : basePath;
+  const assetsBasePath = config.assetsBasePath ?? `${normalizedBasePath || ""}/assets`;
+  const rpcEndpoint = config.rpcUIEndpoint;
+  const shellMode = config.shellMode;
+  return { basePath: normalizedBasePath, assetsBasePath, rpcEndpoint, shellMode };
+}
+function defineReactAppletElement(options) {
+  const tagName = options.tagName.toLowerCase();
+  const registry = getRegistry();
+  const existing = registry.get(tagName);
+  if (existing) {
+    existing.options = options;
+    for (const a of options.observedAttributes ?? []) existing.observed.add(a);
+  } else {
+    const observed = /* @__PURE__ */ new Set(["base-path", "shell-mode", "router-mode"]);
+    for (const a of options.observedAttributes ?? []) observed.add(a);
+    registry.set(tagName, { options, observed });
+  }
+  if (customElements.get(tagName)) {
+    if (typeof window !== "undefined") {
+      window.dispatchEvent(new CustomEvent("iota:applet-host-update", { detail: { tagName } }));
+    }
+    return;
+  }
+  function getEntry() {
+    const entry = getRegistry().get(tagName);
+    if (!entry) throw new Error(`[${tagName}] applet host registry entry missing`);
+    return entry;
+  }
+  class ReactAppletElement extends HTMLElement {
+    constructor() {
+      super(...arguments);
+      this.reactRoot = null;
+      this.container = null;
+      this.darkModeObserver = null;
+      this.styleEl = null;
+      this.updateListener = null;
+    }
+    static get observedAttributes() {
+      return Array.from(getEntry().observed);
+    }
+    connectedCallback() {
+      const shadowRoot = this.shadowRoot ?? this.attachShadow({ mode: "open" });
+      if (!this.container) {
+        this.container = document.createElement("div");
+        this.container.id = "react-root";
+        this.container.style.display = "flex";
+        this.container.style.flexDirection = "column";
+        this.container.style.flex = "1";
+        this.container.style.minHeight = "0";
+        this.container.style.height = "100%";
+        this.container.style.width = "100%";
+      }
+      const existingContainer = shadowRoot.querySelector("#react-root");
+      if (!existingContainer) {
+        if (this.styleEl) shadowRoot.appendChild(this.styleEl);
+        shadowRoot.appendChild(this.container);
+      } else if (existingContainer !== this.container) {
+        this.container = existingContainer;
+      }
+      this.syncFromRegistry();
+      this.updateListener ?? (this.updateListener = (e) => {
+        if (!(e instanceof CustomEvent)) return;
+        const detail = e.detail;
+        if (!detail || detail.tagName !== tagName) return;
+        this.syncFromRegistry();
+        this.renderReact();
+      });
+      window.addEventListener("iota:applet-host-update", this.updateListener);
+      this.renderReact();
+    }
+    disconnectedCallback() {
+      if (this.updateListener) {
+        window.removeEventListener("iota:applet-host-update", this.updateListener);
+      }
+      this.darkModeObserver?.disconnect();
+      this.darkModeObserver = null;
+      this.reactRoot?.unmount();
+      this.reactRoot = null;
+    }
+    attributeChangedCallback(_name, oldValue, newValue) {
+      if (oldValue === newValue) return;
+      if (this.container) this.renderReact();
+    }
+    getHostConfig() {
+      const attrs = {};
+      for (const { name, value } of Array.from(this.attributes)) {
+        attrs[name] = value;
+      }
+      const basePath = this.getAttribute("base-path") ?? "";
+      const shellMode = this.getAttribute("shell-mode") ?? void 0;
+      const routerMode = this.getAttribute("router-mode") ?? "url";
+      return { basePath, shellMode, routerMode, attrs };
+    }
+    renderReact() {
+      if (!this.container) return;
+      if (!this.reactRoot) {
+        this.reactRoot = client.createRoot(this.container);
+      }
+      try {
+        this.reactRoot.render(getEntry().options.render(this.getHostConfig()));
+      } catch (err) {
+        console.error(`[${tagName}] failed to mount React app:`, err);
+      }
+    }
+    syncFromRegistry() {
+      const entry = getEntry();
+      const styles = typeof entry.options.styles === "function" ? entry.options.styles() : entry.options.styles;
+      if (styles) {
+        this.styleEl ?? (this.styleEl = document.createElement("style"));
+        this.styleEl.textContent = styles;
+        if (this.shadowRoot && !this.shadowRoot.contains(this.styleEl)) {
+          this.shadowRoot.insertBefore(this.styleEl, this.shadowRoot.firstChild);
+        }
+      } else if (this.styleEl) {
+        this.styleEl.remove();
+        this.styleEl = null;
+      }
+      if (entry.options.observeDarkMode !== false) {
+        this.darkModeObserver ?? (this.darkModeObserver = this.syncDarkMode());
+      } else if (this.darkModeObserver) {
+        this.darkModeObserver.disconnect();
+        this.darkModeObserver = null;
+      }
+    }
+    syncDarkMode() {
+      const root = this.container;
+      if (!root) throw new Error("react root container not found");
+      const apply = () => {
+        if (document.documentElement.classList.contains("dark")) root.classList.add("dark");
+        else root.classList.remove("dark");
+      };
+      apply();
+      const observer = new MutationObserver(apply);
+      observer.observe(document.documentElement, { attributes: true, attributeFilter: ["class"] });
+      return observer;
+    }
+  }
+  customElements.define(tagName, ReactAppletElement);
+}
+function getRegistry() {
+  const anyGlobal = globalThis;
+  anyGlobal.__IOTA_REACT_APPLET_HOST_REGISTRY__ ?? (anyGlobal.__IOTA_REACT_APPLET_HOST_REGISTRY__ = /* @__PURE__ */ new Map());
+  return anyGlobal.__IOTA_REACT_APPLET_HOST_REGISTRY__;
+}
+
+// ui/src/applet-devtools/enabled.ts
+function shouldEnableAppletDevtools() {
+  if (typeof window === "undefined") return false;
+  const url = new URL(window.location.href);
+  if (url.searchParams.get("appletDebug") === "1") return true;
+  try {
+    return window.localStorage.getItem("iotaAppletDevtools") === "1";
+  } catch {
+    return false;
+  }
+}
+
+// ui/src/applet-host/rpc.ts
+var AppletRPCException = class extends Error {
+  constructor(args) {
+    super(args.message);
+    this.name = "AppletRPCException";
+    this.code = args.code;
+    this.details = args.details;
+    this.cause = args.cause;
+  }
+};
+function createAppletRPCClient(options) {
+  const fetcher = options.fetcher ?? fetch;
+  async function call(method, params) {
+    const req = { id: crypto.randomUUID(), method, params };
+    const startedAt = typeof performance !== "undefined" ? performance.now() : Date.now();
+    maybeDispatchRPCEvent({
+      id: req.id,
+      method: req.method,
+      status: "start"
+    });
+    try {
+      const resp = await fetcher(options.endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(req)
+      });
+      if (!resp.ok) {
+        throw new AppletRPCException({
+          code: "http_error",
+          message: `HTTP ${resp.status}`,
+          details: { status: resp.status }
+        });
+      }
+      const json = await resp.json();
+      if (json.error) {
+        throw new AppletRPCException({
+          code: json.error.code,
+          message: json.error.message,
+          details: json.error.details
+        });
+      }
+      if (json.result === void 0) {
+        throw new AppletRPCException({
+          code: "invalid_response",
+          message: "Missing result in successful response"
+        });
+      }
+      maybeDispatchRPCEvent({
+        id: req.id,
+        method: req.method,
+        status: "success",
+        durationMs: elapsedMs(startedAt)
+      });
+      return json.result;
+    } catch (err) {
+      maybeDispatchRPCEvent({
+        id: req.id,
+        method: req.method,
+        status: "error",
+        durationMs: elapsedMs(startedAt),
+        error: err
+      });
+      throw err;
+    }
+  }
+  async function callTyped(method, params) {
+    return call(method, params);
+  }
+  return { call, callTyped };
+}
+function maybeDispatchRPCEvent(detail) {
+  if (typeof window === "undefined") return;
+  if (!shouldEnableAppletDevtools()) return;
+  window.dispatchEvent(new CustomEvent("iota:applet-rpc", { detail }));
+}
+function elapsedMs(startedAt) {
+  const now = typeof performance !== "undefined" ? performance.now() : Date.now();
+  return Math.max(0, Math.round(now - startedAt));
+}
+function createAppletRouter(options) {
+  const basePath = options.basePath ?? "";
+  const Router = ({ children }) => {
+    if (options.mode === "memory") {
+      const MemoryRouter = options.MemoryRouter;
+      return /* @__PURE__ */ jsxRuntime.jsx(MemoryRouter, { children });
+    }
+    const BrowserRouter = options.BrowserRouter;
+    return /* @__PURE__ */ jsxRuntime.jsx(BrowserRouter, { basename: basePath, children });
+  };
+  return { Router };
+}
+function AppletDevtoolsOverlay() {
+  const ctx = useAppletContext();
+  const runtime = useAppletRuntime();
+  const [rpcEvents, setRPCEvents] = react.useState([]);
+  react.useEffect(() => {
+    const onEvent = (e) => {
+      if (!(e instanceof CustomEvent)) return;
+      const detail = e.detail;
+      if (!detail) return;
+      setRPCEvents((prev) => [detail, ...prev].slice(0, 50));
+    };
+    window.addEventListener("iota:applet-rpc", onEvent);
+    return () => window.removeEventListener("iota:applet-rpc", onEvent);
+  }, []);
+  const summary = react.useMemo(() => {
+    return {
+      basePath: runtime.basePath,
+      assetsBasePath: runtime.assetsBasePath,
+      rpcEndpoint: runtime.rpcEndpoint,
+      shellMode: runtime.shellMode,
+      route: ctx.route,
+      user: { id: ctx.user.id, email: ctx.user.email },
+      tenant: ctx.tenant
+    };
+  }, [ctx.route, ctx.tenant, ctx.user.email, ctx.user.id, runtime.assetsBasePath, runtime.basePath, runtime.rpcEndpoint, runtime.shellMode]);
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      style: {
+        position: "fixed",
+        right: 12,
+        bottom: 12,
+        width: 420,
+        maxHeight: "60vh",
+        overflow: "auto",
+        background: "rgba(17, 24, 39, 0.92)",
+        color: "#E5E7EB",
+        border: "1px solid rgba(255,255,255,0.12)",
+        borderRadius: 10,
+        padding: 12,
+        fontFamily: 'ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace',
+        fontSize: 12,
+        zIndex: 2147483647
+      },
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { display: "flex", justifyContent: "space-between", alignItems: "center", marginBottom: 8 }, children: [
+          /* @__PURE__ */ jsxRuntime.jsx("div", { style: { fontWeight: 700 }, children: "Applet Devtools" }),
+          /* @__PURE__ */ jsxRuntime.jsx("div", { style: { opacity: 0.7 }, children: runtime.shellMode ?? "unknown" })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { marginBottom: 10 }, children: [
+          /* @__PURE__ */ jsxRuntime.jsx("div", { style: { opacity: 0.85, marginBottom: 4 }, children: "Context" }),
+          /* @__PURE__ */ jsxRuntime.jsx("pre", { style: { margin: 0, whiteSpace: "pre-wrap", wordBreak: "break-word" }, children: JSON.stringify(summary, null, 2) })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+          /* @__PURE__ */ jsxRuntime.jsx("div", { style: { opacity: 0.85, marginBottom: 4 }, children: "RPC" }),
+          rpcEvents.length === 0 ? /* @__PURE__ */ jsxRuntime.jsx("div", { style: { opacity: 0.7 }, children: "No calls yet" }) : /* @__PURE__ */ jsxRuntime.jsx("div", { style: { display: "flex", flexDirection: "column", gap: 6 }, children: rpcEvents.map((ev) => /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { padding: 8, border: "1px solid rgba(255,255,255,0.08)", borderRadius: 8 }, children: [
+            /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { display: "flex", justifyContent: "space-between" }, children: [
+              /* @__PURE__ */ jsxRuntime.jsx("div", { children: ev.method }),
+              /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { opacity: 0.8 }, children: [
+                ev.status,
+                typeof ev.durationMs === "number" ? ` (${ev.durationMs}ms)` : ""
+              ] })
+            ] }),
+            ev.status === "error" ? /* @__PURE__ */ jsxRuntime.jsx("pre", { style: { margin: "6px 0 0", opacity: 0.8, whiteSpace: "pre-wrap", wordBreak: "break-word" }, children: JSON.stringify(serializeError(ev.error) ?? {}, null, 2) }) : null
+          ] }, `${ev.id}:${ev.status}`)) })
+        ] })
+      ]
+    }
+  );
+}
+function serializeError(err) {
+  if (err instanceof Error) {
+    const anyErr = err;
+    const out = {
+      name: err.name,
+      message: err.message
+    };
+    if (err.stack) out.stack = err.stack;
+    if (typeof anyErr.code === "string") out.code = anyErr.code;
+    if (anyErr.details !== void 0) out.details = anyErr.details;
+    if (anyErr.cause !== void 0) out.cause = anyErr.cause;
+    return out;
+  }
+  return err;
+}
+
+exports.AppletDevtoolsOverlay = AppletDevtoolsOverlay;
 exports.AppletProvider = AppletProvider;
+exports.AppletRPCException = AppletRPCException;
 exports.ConfigProvider = ConfigProvider;
+exports.createAppletRPCClient = createAppletRPCClient;
+exports.createAppletRouter = createAppletRouter;
+exports.defineReactAppletElement = defineReactAppletElement;
+exports.shouldEnableAppletDevtools = shouldEnableAppletDevtools;
 exports.useAppletContext = useAppletContext;
 exports.useAppletContextDirect = useAppletContext2;
+exports.useAppletRuntime = useAppletRuntime;
 exports.useConfig = useConfig;
 exports.useConfigContext = useConfigContext;
 exports.usePermissions = usePermissions;