@myop/sdk 0.3.36 → 0.4.0-beta.0

package/dist/module/helpers/cloudRepositoryHelpers.d.ts

@@ -14,6 +14,105 @@ export declare const setCloudRepositoryUrl: (url: string) => void;
  *   `${cdnUrl}/components/${componentId}/${environment}.json`
  */
 export declare const enableSelfHosted: (cdnUrl: string, queryParams?: Record<string, string>) => void;
+/**
+ * THE OPT-IN. One call, and nothing changes for anyone who does not make it.
+ *
+ *   myop.delivery({ minify: true });
+ *
+ * Opting in IS choosing the delivery lane: a second, complete Myop stack (its own server
+ * and CDN) reading the same component data. So this call does two things at once — it
+ * points `/consume` at that stack and asks it for the minified artifact — which is why
+ * turning the feature off is a config value on our side or one line on yours, and never
+ * a DNS change.
+ *
+ * Safety properties, all deliberate:
+ *   - If the lane fails (transport error or 5xx), the SDK retries ONCE against
+ *     cloud.myop.dev and the page renders anyway. `delivery.stats().fellBack` counts it.
+ *   - `cache: true` adds the client window: a component this browser already holds, still
+ *     inside the freshness the server promised, is rendered with NO request. Once the
+ *     window ends the browser sends back the version it holds instead of re-downloading.
+ *   - A preview is never minified and never cached.
+ *   - Only /consume moves. Everything else keeps the host it has today.
+ *   - Asking for `minify` does not force it: the server decides per component, and a
+ *     component that is not enabled is served raw, which is not an error.
+ *
+ * `host` is for us (a staging lane, a local server); leave it out.
+ */
+export declare const DELIVERY_HOST = "https://delivery.myop.dev";
+export declare const delivery: (opts?: {
+    minify?: boolean;
+    cache?: boolean;
+    host?: string | null;
+}) => {
+    host: string;
+    minify: boolean;
+    cache: boolean;
+    requests: number;
+    viaDelivery: number;
+    fellBack: number;
+    lastError: string | null;
+    fromMemory: number;
+    fromStorage: number;
+    fromNetwork: number;
+    revalidations: number;
+    unchanged: number;
+    bytesSaved: number;
+};
+/**
+ * Forget what this browser holds, so the next load asks the server. Use it when a change
+ * has to be visible on THIS load — right after someone publishes — rather than within the
+ * freshness window.
+ */
+export declare const deliveryRefresh: () => Promise<{
+    host: string;
+    minify: boolean;
+    cache: boolean;
+    requests: number;
+    viaDelivery: number;
+    fellBack: number;
+    lastError: string | null;
+    fromMemory: number;
+    fromStorage: number;
+    fromNetwork: number;
+    revalidations: number;
+    unchanged: number;
+    bytesSaved: number;
+}>;
+/**
+ * What answered the last requests, and — the number worth watching — how many times the
+ * SDK had to fall back to the default host because the lane did not answer.
+ */
+export declare const deliveryStats: () => {
+    host: string;
+    minify: boolean;
+    cache: boolean;
+    requests: number;
+    viaDelivery: number;
+    fellBack: number;
+    lastError: string | null;
+    fromMemory: number;
+    fromStorage: number;
+    fromNetwork: number;
+    revalidations: number;
+    unchanged: number;
+    bytesSaved: number;
+};
+/** Undo delivery(): back to the default host and raw bytes, with no reload. */
+export declare const deliveryOff: () => {
+    host: string;
+    minify: boolean;
+    cache: boolean;
+    requests: number;
+    viaDelivery: number;
+    fellBack: number;
+    lastError: string | null;
+    fromMemory: number;
+    fromStorage: number;
+    fromNetwork: number;
+    revalidations: number;
+    unchanged: number;
+    bytesSaved: number;
+};
 export declare const setCloudRepository: (repository: CloudRepository) => void;
 export declare const setEnvironment: (env: string) => void;
 export declare const getResolvedConfig: (componentId: string, env?: string, preview?: boolean) => IComponentConfig;

package/dist/module/helpers/deliveryStore.d.ts

@@ -0,0 +1,51 @@
+/**
+ * The client window: what a returning visitor does NOT ask for.
+ *
+ * A component the browser already holds, still inside its freshness window, is rendered
+ * with no network at all. Once the window ends the browser does not re-download it either
+ * — it sends back the version it holds and is usually told "unchanged" in a few hundred
+ * bytes.
+ *
+ * THE WINDOW IS THE SERVER'S, NOT OURS. It comes from the response: `s-maxage` is the
+ * freshness the server promised, and `Age` is how much of it a CDN already spent before
+ * the bytes reached us. The window we may keep is therefore `s-maxage - Age`, never
+ * `s-maxage` — otherwise a copy that sat at the edge for 55 of its 60 seconds would be
+ * held for another 60 here, and a publish would take twice as long to be seen as promised.
+ * This is the single easiest thing to get wrong in a client cache, and it is invisible in
+ * testing because it only shows up as "sometimes stale".
+ *
+ * IndexedDB, not localStorage: components run to hundreds of KB, localStorage caps around
+ * 5 MB and blocks the main thread. Every path degrades to the network — a browser in
+ * private mode, with storage disabled or over quota, must render the page, not fail it.
+ */
+export interface StoredEntry {
+    key: string;
+    /** the resolved component config, exactly as the network path produces it */
+    config: any;
+    /** the server's version token for these bytes: `<rev>~<opt>` */
+    tag: string | null;
+    /** when this browser stored it */
+    storedAt: number;
+    /** how long it may be used without asking, in ms (already Age-adjusted) */
+    windowMs: number;
+    /** which host produced it — a key from another host is never reused */
+    host: string;
+    /** wire size of the response it came from, so stats can say what the window saved */
+    bytes?: number;
+}
+export declare const deliveryStore: {
+    key(host: string, componentId: string, env: string, preview: boolean, opt: string): string;
+    get(key: string): Promise<StoredEntry | null>;
+    put(entry: StoredEntry): Promise<void>;
+    drop(key: string): Promise<void>;
+    /** Still usable without asking the server? */
+    fresh(e: StoredEntry | null): boolean;
+    /**
+     * The window this response licenses: the server's freshness minus what a CDN already
+     * spent. Returns 0 when the server said nothing about caching, which means "do not
+     * hold this" — the safe reading, and what production sends today.
+     */
+    windowFrom(headers: Headers): number;
+    /** For tests and for `refresh()`: forget everything this browser holds. */
+    clear(): Promise<void>;
+};