@tailorkit/client-core 0.1.0-beta.23 → 0.1.0-beta.24

package/dist/{chunk-RNTQ3LLF.js → chunk-BLDTSDUG.js}

@@ -1,5 +1,52 @@
 // src/store/fetch/cache.ts
-import { atom } from "nanostores";
+import { computedAsync } from "@nanostores/async";
+
+// src/store/snapshot-store.ts
+import { atom, onStart, onStop, readonlyType } from "nanostores";
+function createSnapshotStore(getSnapshot, subscribe) {
+  const state = atom(getSnapshot());
+  let stop;
+  const sync = () => state.set(getSnapshot());
+  state.get = () => {
+    sync();
+    return state.value;
+  };
+  onStart(state, () => {
+    stop = subscribe(sync);
+    sync();
+  });
+  onStop(state, () => {
+    stop?.();
+    stop = void 0;
+  });
+  return readonlyType(state);
+}
+function switchStore(selection) {
+  return createSnapshotStore(
+    () => selection.get().get(),
+    (listener) => {
+      let current = selection.get();
+      let stopCurrent = current.listen(listener);
+      const stopSelection = selection.listen(() => {
+        const next = selection.get();
+        if (next !== current) {
+          const previousStop = stopCurrent;
+          current = next;
+          stopCurrent = next.listen(listener);
+          previousStop();
+        }
+        listener();
+      });
+      return () => {
+        stopSelection();
+        stopCurrent();
+      };
+    }
+  );
+}
+
+// src/store/fetch/cache.ts
+import { atom as atom2 } from "nanostores";
 var idle = () => ({
   data: void 0,
   error: null,
@@ -63,7 +110,7 @@ function createFetchCache(defaults = {}) {
         let entry = entries.get(key);
         if (!entry) {
           entry = {
-            state: atom(idle()),
+            state: atom2(idle()),
             controller: null,
             pending: null,
             observers: 0,
@@ -123,38 +170,42 @@ function createFetchCache(defaults = {}) {
           const controller = new AbortController();
           entry.controller = controller;
           const generation = ++entry.generation;
-          const run = async () => {
-            try {
-              const data = await fetcher(controller.signal);
-              if (entry.generation !== generation) return;
-              entry.invalidated = false;
-              entry.state.set({
-                data,
-                error: null,
-                status: "ready",
-                isFetching: false,
-                updatedAt: Date.now()
-              });
-            } catch (error) {
-              if (entry.generation !== generation) return;
-              entry.state.set({
-                ...entry.state.get(),
-                error: error instanceof Error ? error : new Error(String(error)),
-                status: "error",
-                isFetching: false
-              });
-            } finally {
-              if (entry.generation === generation) {
-                entry.controller = null;
-                entry.pending = null;
-                scheduleGc(key, entry);
-              }
-            }
-          };
           let start;
           const pending = new Promise((resolve) => {
             start = () => {
-              void run().then(resolve);
+              const request = computedAsync(atom2(controller.signal), (signal) => {
+                signal.throwIfAborted();
+                return fetcher(signal);
+              });
+              const stop = request.listen((result) => {
+                if (result.state === "loading") return;
+                stop();
+                if (entry.generation === generation) {
+                  if (result.state === "ready") {
+                    entry.invalidated = false;
+                    entry.state.set({
+                      data: result.value,
+                      error: null,
+                      status: "ready",
+                      isFetching: false,
+                      updatedAt: Date.now()
+                    });
+                  } else {
+                    entry.state.set({
+                      ...entry.state.get(),
+                      error: result.error instanceof Error ? result.error : new Error(String(result.error)),
+                      status: "error",
+                      isFetching: false
+                    });
+                  }
+                  if (entry.generation === generation) {
+                    entry.controller = null;
+                    entry.pending = null;
+                    scheduleGc(key, entry);
+                  }
+                }
+                resolve();
+              });
             };
           });
           entry.pending = pending;
@@ -190,7 +241,7 @@ function createFetchCache(defaults = {}) {
           return entry.observers ? store.fetch({ force: true }) : Promise.resolve();
         }
       };
-      return store;
+      return { ...store, state: createSnapshotStore(store.getSnapshot, store.subscribe) };
     },
     clear() {
       for (const [key, entry] of entries) {
@@ -208,95 +259,6 @@ function toBaseUrl(value) {
   return url;
 }
 
-// src/client/endpoints.ts
-import { createClient, createSessionProvider, reference } from "@tailorkit/app/client";
-import { previewMetadataSchema } from "@tailorkit/client-platform/preview";
-var resolveInstances = reference(
-  "_tailorkit.instances.resolve",
-  "action"
-);
-function createEndpointClient(options) {
-  const baseUrl = toBaseUrl(options.baseUrl);
-  const request = (input, init) => (options.fetch ?? globalThis.fetch)(input, init);
-  const sessions = /* @__PURE__ */ new Map();
-  const createSessionEntry = (appId, key) => ({
-    key,
-    session: createSessionProvider({ baseUrl, appId, fetch: request }),
-    // Mounted consumers keep this wrapper, so resolve the current provider on every call.
-    provider: async (input) => {
-      let current = sessions.get(appId);
-      if (!current) {
-        current = createSessionEntry(appId);
-        sessions.set(appId, current);
-      }
-      const session = current.session;
-      const value = await session(input);
-      if (current.session !== session) {
-        throw new DOMException("The app session was invalidated", "AbortError");
-      }
-      return value;
-    }
-  });
-  const getSessionProvider = (app) => {
-    const key = JSON.stringify([app.currentDeployment?.id, app.preview?.sessionId]);
-    let entry = sessions.get(app.id);
-    if (entry && entry.key === void 0) entry.key = key;
-    if (!entry || entry.key !== key) {
-      if (entry) entry.session = void 0;
-      entry = createSessionEntry(app.id, key);
-      sessions.set(app.id, entry);
-    }
-    return entry.provider;
-  };
-  return {
-    baseUrl,
-    async apps(signal) {
-      const response = await request(new URL("apps", baseUrl), {
-        signal,
-        credentials: "same-origin"
-      });
-      if (!response.ok)
-        throw new Error(`Unable to fetch TailorKit apps from ${baseUrl.toString()}.`);
-      return await response.json();
-    },
-    async meta(signal) {
-      const response = await request(new URL("meta", baseUrl), {
-        signal,
-        credentials: "same-origin"
-      });
-      if (!response.ok)
-        throw new Error(`Unable to fetch TailorKit metadata from ${baseUrl.toString()}.`);
-      const value = await response.json();
-      return { ...value, assetsBaseUrl: value.assetsBaseUrl ?? null };
-    },
-    async slotInstances(app, input, signal) {
-      signal.throwIfAborted();
-      const backend = createClient({ getSession: getSessionProvider(app), fetch: request });
-      const abort = () => backend.close();
-      signal.addEventListener("abort", abort, { once: true });
-      try {
-        return await backend.action(resolveInstances, input);
-      } finally {
-        signal.removeEventListener("abort", abort);
-        backend.close();
-      }
-    },
-    async previewMetadata(sessionId) {
-      const url = new URL("preview/metadata", baseUrl);
-      url.searchParams.set("sessionId", sessionId);
-      const response = await request(url, { credentials: "same-origin" });
-      if (response.status === 404) return null;
-      if (!response.ok) throw new Error("Unable to refresh TailorKit preview metadata.");
-      return previewMetadataSchema.parse(await response.json());
-    },
-    getSessionProvider,
-    clearSessions: () => {
-      for (const entry of sessions.values()) entry.session = void 0;
-      sessions.clear();
-    }
-  };
-}
-
 // src/client/slot-view.ts
 import { composeViewContext, getViewHierarchy } from "@tailorkit/core/views";
 function selectSlotView(views, slot, activePath, schema) {
@@ -318,11 +280,121 @@ function resolveSlotView(views, slot, activeView, schema) {
   };
 }
 
+// src/store/fetch/slot.ts
+function createSlotStore(client, options) {
+  const {
+    apps,
+    slot,
+    activeView,
+    staleTime,
+    gcTime,
+    appsStatus = "ready",
+    appsError = null
+  } = options;
+  const enabled = appsStatus === "ready";
+  const settings = {
+    ...staleTime === void 0 ? {} : { staleTime },
+    ...gcTime === void 0 ? {} : { gcTime }
+  };
+  const waiting = {
+    data: void 0,
+    error: appsStatus === "error" ? appsError : null,
+    status: appsStatus,
+    isFetching: false
+  };
+  const query = client.cache.getStore(
+    ["tailorkit", client.baseUrl.toString(), "slot", apps, slot, activeView],
+    async (signal) => {
+      const candidates = apps.filter(
+        (app) => app.views?.some((view) => view.slot === slot && !view.disabled)
+      );
+      if (!candidates.length) return { status: "ready", data: [] };
+      const meta = client.meta();
+      await meta.fetch();
+      signal.throwIfAborted();
+      const snapshot2 = meta.getSnapshot();
+      if (snapshot2.error) throw snapshot2.error;
+      if (!snapshot2.data) throw new Error("TailorKit metadata is unavailable.");
+      const schema = snapshot2.data.schema;
+      const definition = schema.slots[slot];
+      if (!definition) return { status: "ready", data: [] };
+      if (definition.multiple !== true) {
+        return {
+          status: "ready",
+          data: candidates.filter(
+            (app) => app.views?.some(
+              (view) => view.slot === slot && !view.disabled && !view.instances && definition.views.includes(view.path)
+            )
+          ).map((app) => ({ app }))
+        };
+      }
+      if (activeView === null) return { status: "idle" };
+      const matches = candidates.flatMap((app) => {
+        const resolved = resolveSlotView(app.views ?? [], slot, activeView, schema);
+        return resolved?.instances ? [{ app, resolved }] : [];
+      });
+      for (const { resolved } of matches) {
+        if (resolved.status === "error")
+          throw new Error(`Context for view "${resolved.view}" is unavailable.`);
+      }
+      if (matches.some(({ resolved }) => resolved.status !== "ready")) return { status: "loading" };
+      const controller = new AbortController();
+      const abort = () => controller.abort();
+      signal.addEventListener("abort", abort, { once: true });
+      try {
+        const results = await Promise.all(
+          matches.map(async ({ app, resolved }) => {
+            if (resolved.status !== "ready") return [];
+            const data = await client.endpoints.slotInstances(
+              app,
+              { slot, path: resolved.view, context: resolved.context },
+              controller.signal
+            );
+            return data.map((instance) => ({ ...instance, app }));
+          })
+        );
+        return { status: "ready", data: results.flat() };
+      } catch (error) {
+        controller.abort();
+        throw error;
+      } finally {
+        signal.removeEventListener("abort", abort);
+      }
+    },
+    { ...client.cacheOptions?.slot, ...settings, abortOnUnsubscribe: true }
+  );
+  let last;
+  let snapshot;
+  const store = {
+    getSnapshot() {
+      if (!enabled) return waiting;
+      const current = query.getSnapshot();
+      if (current !== last) {
+        snapshot = {
+          data: current.data?.data,
+          error: current.error,
+          status: current.status === "ready" ? current.data.status : current.status,
+          isFetching: current.isFetching
+        };
+        last = current;
+      }
+      return snapshot;
+    },
+    subscribe: (listener) => enabled ? query.subscribe(listener) : () => {
+    },
+    fetch: (fetchOptions = {}) => enabled ? query.fetch(fetchOptions) : Promise.resolve(),
+    invalidate: () => enabled ? query.invalidate() : Promise.resolve()
+  };
+  return { ...store, state: createSnapshotStore(store.getSnapshot, store.subscribe) };
+}
+
 export {
+  createSnapshotStore,
+  switchStore,
   serializeCacheKey,
   createFetchCache,
   toBaseUrl,
-  createEndpointClient,
   selectSlotView,
-  resolveSlotView
+  resolveSlotView,
+  createSlotStore
 };

package/dist/{chunk-K3QITWU4.js → chunk-CWDPTXSZ.js}

@@ -1,7 +1,9 @@
 import {
-  createEndpointClient,
-  resolveSlotView
-} from "./chunk-RNTQ3LLF.js";
+  createEndpointClient
+} from "./chunk-FUBKKH3Q.js";
+import {
+  createSnapshotStore
+} from "./chunk-BLDTSDUG.js";
 
 // src/store/fetch/apps.ts
 import { atom } from "nanostores";
@@ -77,7 +79,7 @@ function createAppsStore(client, initialApps) {
     },
     invalidate: () => supplied ? Promise.resolve() : query.invalidate()
   };
-  return store;
+  return { ...store, state: createSnapshotStore(store.getSnapshot, store.subscribe) };
 }
 
 // src/store/fetch/meta.ts
@@ -85,7 +87,7 @@ function createMetadataStore(client) {
   const query = client.meta();
   let last;
   let snapshot;
-  return {
+  const store = {
     getSnapshot() {
       const current = query.getSnapshot();
       if (current !== last) {
@@ -104,6 +106,7 @@ function createMetadataStore(client) {
     fetch: query.fetch,
     invalidate: query.invalidate
   };
+  return { ...store, state: createSnapshotStore(store.getSnapshot, store.subscribe) };
 }
 
 // src/store/fetch/preview-manager.ts
@@ -275,7 +278,7 @@ function createPreviewManager(baseUrl, onEnded, onViews, refreshMetadata = creat
       }
     });
   };
-  return {
+  const manager = {
     getSnapshot: (sessionId) => entries.get(sessionId)?.state.get() ?? empty,
     updateApp: (app) => {
       const sessionId = app.preview?.sessionId;
@@ -330,118 +333,24 @@ function createPreviewManager(baseUrl, onEnded, onViews, refreshMetadata = creat
       entries.clear();
     }
   };
-}
-
-// src/store/fetch/slot.ts
-function createSlotStore(client, options) {
-  const {
-    apps,
-    slot,
-    activeView,
-    staleTime,
-    gcTime,
-    appsStatus = "ready",
-    appsError = null
-  } = options;
-  const enabled = appsStatus === "ready";
-  const settings = {
-    ...staleTime === void 0 ? {} : { staleTime },
-    ...gcTime === void 0 ? {} : { gcTime }
-  };
-  const waiting = {
-    data: void 0,
-    error: appsStatus === "error" ? appsError : null,
-    status: appsStatus,
-    isFetching: false
-  };
-  const query = client.cache.getStore(
-    ["tailorkit", client.baseUrl.toString(), "slot", apps, slot, activeView],
-    async (signal) => {
-      const candidates = apps.filter(
-        (app) => app.views?.some((view) => view.slot === slot && !view.disabled)
-      );
-      if (!candidates.length) return { status: "ready", data: [] };
-      const meta = client.meta();
-      await meta.fetch();
-      signal.throwIfAborted();
-      const snapshot2 = meta.getSnapshot();
-      if (snapshot2.error) throw snapshot2.error;
-      if (!snapshot2.data) throw new Error("TailorKit metadata is unavailable.");
-      const schema = snapshot2.data.schema;
-      const definition = schema.slots[slot];
-      if (!definition) return { status: "ready", data: [] };
-      if (definition.multiple !== true) {
-        return {
-          status: "ready",
-          data: candidates.filter(
-            (app) => app.views?.some(
-              (view) => view.slot === slot && !view.disabled && !view.instances && definition.views.includes(view.path)
-            )
-          ).map((app) => ({ app }))
-        };
-      }
-      if (activeView === null) return { status: "idle" };
-      const matches = candidates.flatMap((app) => {
-        const resolved = resolveSlotView(app.views ?? [], slot, activeView, schema);
-        return resolved?.instances ? [{ app, resolved }] : [];
-      });
-      for (const { resolved } of matches) {
-        if (resolved.status === "error")
-          throw new Error(`Context for view "${resolved.view}" is unavailable.`);
-      }
-      if (matches.some(({ resolved }) => resolved.status !== "ready")) return { status: "loading" };
-      const controller = new AbortController();
-      const abort = () => controller.abort();
-      signal.addEventListener("abort", abort, { once: true });
-      try {
-        const results = await Promise.all(
-          matches.map(async ({ app, resolved }) => {
-            if (resolved.status !== "ready") return [];
-            const data = await client.endpoints.slotInstances(
-              app,
-              { slot, path: resolved.view, context: resolved.context },
-              controller.signal
-            );
-            return data.map((instance) => ({ ...instance, app }));
-          })
-        );
-        return { status: "ready", data: results.flat() };
-      } catch (error) {
-        controller.abort();
-        throw error;
-      } finally {
-        signal.removeEventListener("abort", abort);
-      }
-    },
-    { ...client.cacheOptions?.slot, ...settings, abortOnUnsubscribe: true }
-  );
-  let last;
-  let snapshot;
   return {
-    getSnapshot() {
-      if (!enabled) return waiting;
-      const current = query.getSnapshot();
-      if (current !== last) {
-        snapshot = {
-          data: current.data?.data,
-          error: current.error,
-          status: current.status === "ready" ? current.data.status : current.status,
-          isFetching: current.isFetching
-        };
-        last = current;
-      }
-      return snapshot;
-    },
-    subscribe: (listener) => enabled ? query.subscribe(listener) : () => {
-    },
-    fetch: (fetchOptions = {}) => enabled ? query.fetch(fetchOptions) : Promise.resolve(),
-    invalidate: () => enabled ? query.invalidate() : Promise.resolve()
+    ...manager,
+    getStore(getApp) {
+      const sessionId = getApp().preview?.sessionId ?? "";
+      return createSnapshotStore(
+        () => manager.getSnapshot(sessionId),
+        (listener) => {
+          const app = getApp();
+          return app.preview?.sessionId === sessionId ? manager.subscribe(app, listener) : () => {
+          };
+        }
+      );
+    }
   };
 }
 
 export {
   createAppsStore,
   createMetadataStore,
-  createPreviewManager,
-  createSlotStore
+  createPreviewManager
 };

package/dist/chunk-FUBKKH3Q.js

@@ -0,0 +1,96 @@
+import {
+  toBaseUrl
+} from "./chunk-BLDTSDUG.js";
+
+// src/client/endpoints.ts
+import { createClient, createSessionProvider, reference } from "@tailorkit/app/client/connection";
+import { previewMetadataSchema } from "@tailorkit/client-platform/preview";
+var resolveInstances = reference(
+  "_tailorkit.instances.resolve",
+  "action"
+);
+function createEndpointClient(options) {
+  const baseUrl = toBaseUrl(options.baseUrl);
+  const request = (input, init) => (options.fetch ?? globalThis.fetch)(input, init);
+  const sessions = /* @__PURE__ */ new Map();
+  const createSessionEntry = (appId, key) => ({
+    key,
+    session: createSessionProvider({ baseUrl, appId, fetch: request }),
+    // Mounted consumers keep this wrapper, so resolve the current provider on every call.
+    provider: async (input) => {
+      let current = sessions.get(appId);
+      if (!current) {
+        current = createSessionEntry(appId);
+        sessions.set(appId, current);
+      }
+      const session = current.session;
+      const value = await session(input);
+      if (current.session !== session) {
+        throw new DOMException("The app session was invalidated", "AbortError");
+      }
+      return value;
+    }
+  });
+  const getSessionProvider = (app) => {
+    const key = JSON.stringify([app.currentDeployment?.id, app.preview?.sessionId]);
+    let entry = sessions.get(app.id);
+    if (entry && entry.key === void 0) entry.key = key;
+    if (!entry || entry.key !== key) {
+      if (entry) entry.session = void 0;
+      entry = createSessionEntry(app.id, key);
+      sessions.set(app.id, entry);
+    }
+    return entry.provider;
+  };
+  return {
+    baseUrl,
+    async apps(signal) {
+      const response = await request(new URL("apps", baseUrl), {
+        signal,
+        credentials: "same-origin"
+      });
+      if (!response.ok)
+        throw new Error(`Unable to fetch TailorKit apps from ${baseUrl.toString()}.`);
+      return await response.json();
+    },
+    async meta(signal) {
+      const response = await request(new URL("meta", baseUrl), {
+        signal,
+        credentials: "same-origin"
+      });
+      if (!response.ok)
+        throw new Error(`Unable to fetch TailorKit metadata from ${baseUrl.toString()}.`);
+      const value = await response.json();
+      return { ...value, assetsBaseUrl: value.assetsBaseUrl ?? null };
+    },
+    async slotInstances(app, input, signal) {
+      signal.throwIfAborted();
+      const backend = createClient({ getSession: getSessionProvider(app), fetch: request });
+      const abort = () => backend.close();
+      signal.addEventListener("abort", abort, { once: true });
+      try {
+        return await backend.action(resolveInstances, input);
+      } finally {
+        signal.removeEventListener("abort", abort);
+        backend.close();
+      }
+    },
+    async previewMetadata(sessionId) {
+      const url = new URL("preview/metadata", baseUrl);
+      url.searchParams.set("sessionId", sessionId);
+      const response = await request(url, { credentials: "same-origin" });
+      if (response.status === 404) return null;
+      if (!response.ok) throw new Error("Unable to refresh TailorKit preview metadata.");
+      return previewMetadataSchema.parse(await response.json());
+    },
+    getSessionProvider,
+    clearSessions: () => {
+      for (const entry of sessions.values()) entry.session = void 0;
+      sessions.clear();
+    }
+  };
+}
+
+export {
+  createEndpointClient
+};