@salesforce/lds-worker-api 1.371.0 → 1.372.1

package/dist/standalone/umd/lds-worker-api.js

@@ -4280,7 +4280,7 @@
         }
         callbacks.push(callback);
     }
-    // version: 1.371.0-e11a80989c
+    // version: 1.372.1-5ff6849fe2
 
     // TODO [TD-0081508]: once that TD is fulfilled we can probably change this file
     function instrumentAdapter$1(createFunction, _metadata) {
@@ -5124,6 +5124,24 @@
         }
         return payload;
     }
+    /**
+     * The graphql batch snapshot should be treated the same as a regular imperative adapter snapshot.
+     * @param snapshot - The snapshot to convert to a tuple
+     * @returns The tuple representation of the snapshot
+     */
+    function batchSnapshotToTuple(snapshot) {
+        if (isErrorSnapshot$2(snapshot)) {
+            return {
+                data: undefined,
+                error: snapshot.error,
+            };
+        }
+        // We might still get pending snapshot here from invoke calls here
+        return {
+            data: snapshot.data,
+            error: undefined,
+        };
+    }
     function createInvalidConfigError() {
         return {
             data: undefined,
@@ -5151,7 +5169,9 @@
         const { name } = metadata;
         const imperativeAdapterInvoke = (config, requestContext, callback) => {
             let coercedConfig = null;
+            let isBatch = false;
             if ('batchQuery' in config) {
+                isBatch = true;
                 coercedConfig = {
                     batchQuery: config.batchQuery.map((individualConfig) => ({
                         ...individualConfig,
@@ -5181,7 +5201,9 @@
                 return;
             }
             if (!isPromise$3(snapshotOrPromise)) {
-                callback(snapshotToTuple(snapshotOrPromise));
+                callback(isBatch
+                    ? batchSnapshotToTuple(snapshotOrPromise)
+                    : snapshotToTuple(snapshotOrPromise));
                 return;
             }
             snapshotOrPromise
@@ -5190,7 +5212,7 @@
                     callback(createInvalidConfigError());
                     return;
                 }
-                callback(snapshotToTuple(snapshot));
+                callback(isBatch ? batchSnapshotToTuple(snapshot) : snapshotToTuple(snapshot));
             })
                 .finally(() => {
                 luvio.storeCleanup();
@@ -5205,7 +5227,9 @@
             let subscriberCallback = callback;
             let unsub;
             let coercedConfig = null;
+            let isBatch = false;
             if ('batchQuery' in config) {
+                isBatch = true;
                 coercedConfig = {
                     batchQuery: config.batchQuery.map((individualConfig) => ({
                         ...individualConfig,
@@ -5238,7 +5262,9 @@
             const luvioStoreSubscribe = (snapshot) => {
                 unsub = luvio.storeSubscribe(snapshot, (snapshotFromRebuild) => {
                     if (subscriberCallback !== null && !isPendingSnapshot(snapshotFromRebuild)) {
-                        subscriberCallback(snapshotToTuple(snapshotFromRebuild));
+                        subscriberCallback(isBatch
+                            ? batchSnapshotToTuple(snapshotFromRebuild)
+                            : snapshotToTuple(snapshotFromRebuild));
                     }
                 });
             };
@@ -5246,7 +5272,9 @@
                 // We don't want to return pending snapshots to user-land
                 // Instead we just subscribe to it
                 if (!isPendingSnapshot(snapshotOrPromise)) {
-                    subscriberCallback(snapshotToTuple(snapshotOrPromise));
+                    subscriberCallback(isBatch
+                        ? batchSnapshotToTuple(snapshotOrPromise)
+                        : snapshotToTuple(snapshotOrPromise));
                 }
                 luvioStoreSubscribe(snapshotOrPromise);
             }
@@ -5261,7 +5289,7 @@
                         // We don't want to return pending snapshots to user-land
                         // Instead we just subscribe to it
                         if (!isPendingSnapshot(snapshot)) {
-                            subscriberCallback(snapshotToTuple(snapshot));
+                            subscriberCallback(isBatch ? batchSnapshotToTuple(snapshot) : snapshotToTuple(snapshot));
                         }
                         luvioStoreSubscribe(snapshot);
                     }
@@ -5296,7 +5324,7 @@
         const { apiFamily, name } = metadata;
         return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
     }
-    // version: 1.371.0-e11a80989c
+    // version: 1.372.1-5ff6849fe2
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -34172,7 +34200,7 @@
         throttle(60, 60000, setupNotifyAllListRecordUpdateAvailable(luvio));
         throttle(60, 60000, setupNotifyAllListInfoSummaryUpdateAvailable(luvio));
     });
-    // version: 1.371.0-1f3d834ba4
+    // version: 1.372.1-8824ae9dd4
 
     function requestIdleDetectedCallback(_callback) { }
     function declareNotifierTaskSingle(_name) {
@@ -94203,14 +94231,20 @@
       async coerceFetchError(errorResponse) {
         return toError(errorResponse.statusText);
       }
+      processAuraReturnValue(auraReturnValue) {
+        return ok$1(auraReturnValue);
+      }
+      processFetchReturnValue(json) {
+        return ok$1(json);
+      }
       convertAuraResponseToData(responsePromise, coerceError) {
         return responsePromise.then((response) => {
-          const auraReturnValue = response.getReturnValue();
+          return this.processAuraReturnValue(response.getReturnValue());
+        }).finally(() => {
           try {
             this.afterRequestHooks({ statusCode: 200 });
           } catch (e) {
           }
-          return ok$1(auraReturnValue);
         }).catch((error) => {
           if (!error || !error.getError) {
             return err$1(toError("Failed to get error from response"));
@@ -94229,7 +94263,9 @@
           (response2) => {
             if (response2.ok) {
               return response2.json().then(
-                (json) => ok$1(json),
+                (json) => {
+                  return this.processFetchReturnValue(json);
+                },
                 (reason) => err$1(toError(reason))
               ).finally(() => {
                 try {
@@ -94334,14 +94370,20 @@
       async coerceFetchError(errorResponse) {
         return toError(errorResponse.statusText);
       }
+      processAuraReturnValue(auraReturnValue) {
+        return ok$1(auraReturnValue);
+      }
+      processFetchReturnValue(json) {
+        return ok$1(json);
+      }
       convertAuraResponseToData(responsePromise, coerceError) {
         return responsePromise.then((response) => {
-          const auraReturnValue = response.getReturnValue();
+          return this.processAuraReturnValue(response.getReturnValue());
+        }).finally(() => {
           try {
             this.afterRequestHooks({ statusCode: 200 });
           } catch (e) {
           }
-          return ok$1(auraReturnValue);
         }).catch((error) => {
           if (!error || !error.getError) {
             return err$1(toError("Failed to get error from response"));
@@ -94360,7 +94402,9 @@
           (response2) => {
             if (response2.ok) {
               return response2.json().then(
-                (json) => ok$1(json),
+                (json) => {
+                  return this.processFetchReturnValue(json);
+                },
                 (reason) => err$1(toError(reason))
               ).finally(() => {
                 try {
@@ -94553,12 +94597,17 @@
       async coerceError(errorResponse) {
         return toError(errorResponse.statusText);
       }
+      processFetchReturnValue(json) {
+        return ok$1(json);
+      }
       convertFetchResponseToData(response) {
         return response.then(
           (response2) => {
             if (response2.ok) {
               return response2.json().then(
-                (json) => ok$1(json),
+                (json) => {
+                  return this.processFetchReturnValue(json);
+                },
                 (reason) => err$1(toError(reason))
               ).finally(() => {
                 try {
@@ -95490,12 +95539,31 @@
         const service = (...args) => {
             const resourceRequest = convertFetchParamsToResourceRequest(args);
             const context = {};
-            return NimbusNetworkAdapter(resourceRequest, context).then((response) => {
-                return new Response(response.body, {
+            return NimbusNetworkAdapter(resourceRequest, context)
+                .then((response) => {
+                // This is a hack to make the response compatible with the Response interface
+                const r = {
+                    body: response.body,
                     headers: response.headers,
                     status: response.status,
                     statusText: response.statusText,
-                });
+                    json: () => {
+                        return Promise.resolve(response.body);
+                    },
+                    ok: response.status >= 200 && response.status < 300,
+                };
+                return r;
+            })
+                .catch((error) => {
+                // Create a Response-like error object
+                return {
+                    body: null,
+                    headers: {},
+                    status: 500,
+                    statusText: error.message || 'Internal Server Error',
+                    json: () => Promise.resolve(null),
+                    ok: false,
+                };
             });
         };
         return {
@@ -95514,38 +95582,113 @@
      * @returns A ResourceRequest object compatible with NimbusNetworkAdapter
      */
     function convertFetchParamsToResourceRequest([input, init]) {
-        const url = typeof input === 'string'
-            ? new URL(input)
-            : input instanceof URL
-                ? input
-                : new URL(input.url);
+        const urlString = typeof input === 'string' ? input : input.href || input.url || input;
+        const { baseUri, basePath, queryParams } = parseUrlParts(urlString);
         const headers = {};
         if (init?.headers) {
-            if (init.headers instanceof Headers) {
+            if (typeof Headers !== 'undefined' && init?.headers instanceof Headers) {
                 init.headers.forEach((value, key) => {
                     headers[key] = value;
                 });
             }
-            else if (Array.isArray(init.headers)) {
+            else if (Array.isArray(init?.headers)) {
                 init.headers.forEach(([key, value]) => {
                     headers[key] = value;
                 });
             }
             else {
-                Object.entries(init.headers).forEach(([key, value]) => {
+                Object.entries(init?.headers || {}).forEach(([key, value]) => {
                     headers[key] = value;
                 });
             }
         }
-        return {
-            baseUri: url.origin,
-            basePath: url.pathname,
+        const resourceRequest = {
+            baseUri,
+            basePath,
             method: (init?.method || 'GET').toLowerCase(),
-            body: init?.body || null,
             headers,
-            queryParams: Object.fromEntries(url.searchParams),
+            body: (() => {
+                if (!init?.body) {
+                    return null;
+                }
+                try {
+                    return typeof init.body === 'string' ? JSON.parse(init.body) : init.body;
+                }
+                catch {
+                    return init.body;
+                }
+            })(),
+            queryParams,
             urlParams: {},
         };
+        return resourceRequest;
+    }
+    function parseUrlParts(urlString) {
+        // Split by protocol first
+        const [protocol, rest] = urlString.split('://');
+        // If no protocol, treat whole string as path
+        if (!rest) {
+            return {
+                baseUri: '',
+                basePath: urlString.startsWith('/')
+                    ? urlString.split('?')[0]
+                    : `/${urlString.split('?')[0]}`,
+                queryParams: extractQueryParams(urlString),
+            };
+        }
+        // Split remaining parts
+        const parts = rest.split('/');
+        let hostPart = parts[0] || '';
+        const pathParts = parts.slice(1);
+        // Handle query string in host part (e.g., "example.com?key=value")
+        let hostQueryString = '';
+        if (hostPart.includes('?')) {
+            const [host, query] = hostPart.split('?');
+            hostPart = host;
+            hostQueryString = query;
+        }
+        // Handle query string in path parts
+        const lastPart = pathParts[pathParts.length - 1] || '';
+        const [pathEnd, pathQueryString] = lastPart.split('?');
+        // Combine query strings (host takes precedence if both exist)
+        const queryString = hostQueryString || pathQueryString;
+        // Reconstruct
+        const baseUri = hostPart ? `${protocol}://${hostPart}` : urlString;
+        const basePath = pathParts.length > 0 ? `/${pathParts.slice(0, -1).concat(pathEnd).join('/')}` : '/';
+        const queryParams = {};
+        if (queryString) {
+            queryString.split('&').forEach((param) => {
+                const [key, value = ''] = param.split('=');
+                if (key) {
+                    try {
+                        queryParams[decodeURIComponent(key)] = decodeURIComponent(value);
+                    }
+                    catch {
+                        queryParams[key] = value;
+                    }
+                }
+            });
+        }
+        return { baseUri, basePath, queryParams };
+    }
+    function extractQueryParams(urlString) {
+        const queryParams = {};
+        const queryStart = urlString.indexOf('?');
+        if (queryStart > -1) {
+            const queryString = urlString.substring(queryStart + 1);
+            queryString.split('&').forEach((param) => {
+                const [key, value = ''] = param.split('=');
+                if (key) {
+                    try {
+                        queryParams[decodeURIComponent(key)] = decodeURIComponent(value);
+                    }
+                    catch {
+                        queryParams[key] = value;
+                    }
+                }
+            });
+        }
+        return queryParams;
     }
 
     /*!
@@ -96075,6 +96218,10 @@
         if (!useOneStore.isOpen({ fallback: true })) {
             return;
         }
+        // Initialize performance.now() fallback if not available
+        if (typeof globalThis.performance === 'undefined') {
+            globalThis.performance = { now: () => Date.now() };
+        }
         const loggerService = new ConsoleLogger('ERROR');
         const cacheServiceDescriptor = buildServiceDescriptor$6();
         const instrumentationServiceDescriptor = buildServiceDescriptor$3(loggerService);
@@ -96302,7 +96449,7 @@
         id: '@salesforce/lds-network-adapter',
         instrument: instrument$2,
     });
-    // version: 1.371.0-e11a80989c
+    // version: 1.372.1-5ff6849fe2
 
     const { create: create$2, keys: keys$2 } = Object;
     const { stringify, parse } = JSON;
@@ -122793,7 +122940,7 @@
         }
         return refresh$3(data, 'refreshUiApi');
     }
-    // version: 1.371.0-1f3d834ba4
+    // version: 1.372.1-8824ae9dd4
 
     // On core the unstable adapters are re-exported with different names,
     // we want to match them here.
@@ -122945,7 +123092,7 @@
         unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
         graphQLImperative = ldsAdapter;
     });
-    // version: 1.371.0-1f3d834ba4
+    // version: 1.372.1-8824ae9dd4
 
     var gqlApi = /*#__PURE__*/Object.freeze({
         __proto__: null,
@@ -123744,7 +123891,7 @@
     function register(r) {
         callbacks$1.forEach((callback) => callback(r));
     }
-    // version: 1.371.0-e11a80989c
+    // version: 1.372.1-5ff6849fe2
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -124924,6 +125071,155 @@
         }
     }
 
+    const ONESTORE_ADAPTER_FAMILY = /^force\/ldsAdapters/;
+    function buildOneStoreError(error) {
+        let errorMessage;
+        if (typeof error === 'string') {
+            errorMessage = error;
+        }
+        else if (error && error.message) {
+            errorMessage = error.message;
+        }
+        else if (error !== null && error !== undefined) {
+            errorMessage = error.toString();
+        }
+        else {
+            errorMessage = error;
+        }
+        return {
+            data: undefined,
+            error: errorMessage,
+        };
+    }
+    function buildInvalidAdapterError(adapterOrCommandName) {
+        return {
+            data: undefined,
+            error: `Invalid adapter or command: ${adapterOrCommandName}`,
+        };
+    }
+    function buildNativeResponse(response) {
+        if (response && response.error) {
+            return buildOneStoreError(response.error);
+        }
+        return response;
+    }
+    async function importOneStoreAdapterModule(specifier) {
+        if (!ONESTORE_ADAPTER_FAMILY.test(specifier)) {
+            throw `${specifier} is not an allowed onestore adapter module`;
+        }
+        let module;
+        try {
+            module = await import(specifier);
+        }
+        catch {
+            throw `module not found for specifier ${specifier}`;
+        }
+        return new OneStoreAdapterModule(module);
+    }
+    class OneStoreAdapterModule {
+        constructor(module) {
+            this.module = module;
+        }
+        async invoke(adapterOrCommandName, config) {
+            const adapterOrCommand = this.module[adapterOrCommandName];
+            if (adapterOrCommand === undefined) {
+                return buildInvalidAdapterError(`Command ${adapterOrCommandName} not recognized`);
+            }
+            return new Promise((resolve) => {
+                try {
+                    if (this.isCommandWireAdapter(adapterOrCommand)) {
+                        // WIRE COMMAND
+                        const adapter = new adapterOrCommand((result) => {
+                            resolve(buildNativeResponse(result));
+                            adapter.disconnect();
+                        }, undefined, { skipEmptyEmit: true });
+                        adapter.connect();
+                        adapter.update(config);
+                    }
+                    else if (this.hasInvoke(adapterOrCommand)) {
+                        // IMPERATIVE LEGACY INVOKER
+                        adapterOrCommand.invoke(config, null, (result) => {
+                            resolve(buildNativeResponse(result));
+                        });
+                    }
+                    else {
+                        // IMPERATIVE INVOKER
+                        adapterOrCommand(config)
+                            .then((response) => {
+                            resolve(buildNativeResponse(response));
+                        })
+                            .catch((error) => {
+                            resolve(buildOneStoreError(error));
+                        });
+                    }
+                }
+                catch (error) {
+                    resolve(buildInvalidAdapterError(adapterOrCommandName));
+                }
+            });
+        }
+        subscribe(adapterOrCommandName, config, callback) {
+            const adapterOrCommand = this.module[adapterOrCommandName];
+            if (adapterOrCommand === undefined) {
+                callback(buildInvalidAdapterError(adapterOrCommandName));
+                return Promise.resolve(undefined);
+            }
+            return new Promise((resolve) => {
+                try {
+                    if (this.isCommandWireAdapter(adapterOrCommand)) {
+                        // WIRE COMMAND
+                        const adapter = new adapterOrCommand((result) => {
+                            callback(buildNativeResponse(result));
+                        }, undefined, { skipEmptyEmit: true });
+                        adapter.connect();
+                        adapter.update(config);
+                        resolve(() => adapter.disconnect());
+                    }
+                    else if (this.hasSubscribe(adapterOrCommand)) {
+                        // IMPERATIVE LEGACY INVOKER
+                        const unsubscribe = adapterOrCommand.subscribe(config, null, (result) => {
+                            callback(buildNativeResponse(result));
+                        });
+                        resolve(unsubscribe);
+                    }
+                    else {
+                        // IMPERATIVE INVOKER
+                        adapterOrCommand(config)
+                            .then((response) => {
+                            if (response.subscribe === undefined) {
+                                callback(buildNativeResponse(response));
+                                resolve(undefined);
+                            }
+                            else {
+                                const unsubscribe = response.subscribe((subscriptionResult) => {
+                                    callback(buildNativeResponse(subscriptionResult));
+                                });
+                                resolve(unsubscribe);
+                            }
+                        })
+                            .catch((error) => {
+                            callback(buildOneStoreError(error));
+                            resolve(undefined);
+                        });
+                    }
+                }
+                catch (error) {
+                    callback(buildInvalidAdapterError(adapterOrCommandName));
+                    resolve(undefined);
+                }
+            });
+        }
+        isCommandWireAdapter(adapterOrCommand) {
+            return Object.getPrototypeOf(adapterOrCommand).name === 'CommandWireAdapterConstructor';
+        }
+        hasInvoke(adapterOrCommand) {
+            return typeof adapterOrCommand.invoke === 'function';
+        }
+        hasSubscribe(adapterOrCommand) {
+            return typeof adapterOrCommand.subscribe === 'function';
+        }
+    }
+
     // LWR has a "setupLDS" bootstrap service/loader hook, we simulate this in
     // standalone bundle by mimicking what "setupLDS" does here and then exporting
     // everything from main.ts
@@ -124939,6 +125235,7 @@
     exports.executeMutatingAdapter = executeMutatingAdapter;
     exports.getImperativeAdapterNames = getImperativeAdapterNames;
     exports.importLuvioAdapterModule = importLuvioAdapterModule;
+    exports.importOneStoreAdapterModule = importOneStoreAdapterModule;
     exports.invokeAdapter = invokeAdapter;
     exports.invokeAdapterWithDraftToMerge = invokeAdapterWithDraftToMerge;
     exports.invokeAdapterWithDraftToReplace = invokeAdapterWithDraftToReplace;
@@ -124951,4 +125248,4 @@
     exports.subscribeToAdapter = subscribeToAdapter;
 
 }));
-// version: 1.371.0-e11a80989c
+// version: 1.372.1-5ff6849fe2

package/dist/standalone/umd/types/customOneStoreAdapter.d.ts

@@ -0,0 +1,21 @@
+import type { Unsubscribe } from '@luvio/engine';
+export type OneStoreNativeCallbackValue = OneStoreNativeCallbackData | OneStoreNativeCallbackError;
+export type OneStoreNativeCallbackData = {
+    data: any | undefined;
+    error?: undefined;
+};
+export type OneStoreNativeCallbackError = {
+    data?: undefined;
+    error: string;
+};
+export declare function importOneStoreAdapterModule(specifier: string): Promise<OneStoreAdapterModule>;
+declare class OneStoreAdapterModule {
+    module: any;
+    constructor(module: any);
+    invoke<Config>(adapterOrCommandName: string, config: Config): Promise<OneStoreNativeCallbackValue>;
+    subscribe<Config>(adapterOrCommandName: string, config: Config, callback: (value: OneStoreNativeCallbackValue) => void): Promise<Unsubscribe | undefined>;
+    private isCommandWireAdapter;
+    private hasInvoke;
+    private hasSubscribe;
+}
+export {};

package/dist/standalone/umd/types/main.d.ts

@@ -7,4 +7,5 @@ import { registerReportObserver } from '@salesforce/lds-runtime-mobile';
 import { createPrimingSession } from './primingApi';
 import { evictCacheRecordsByIds, evictExpiredCacheEntries, stopEviction } from './cachePurging';
 import { importLuvioAdapterModule } from './customLuvioAdapter';
-export { subscribeToAdapter, invokeAdapter, invokeAdapterWithMetadata, invokeAdapterWithDraftToReplace, invokeAdapterWithDraftToMerge, executeAdapter, executeMutatingAdapter, nimbusDraftQueue, draftQueue, draftManager, setUiApiRecordTTL, setMetadataTTL, registerReportObserver, getImperativeAdapterNames, createPrimingSession, evictCacheRecordsByIds, evictExpiredCacheEntries, stopEviction, importLuvioAdapterModule, };
+import { importOneStoreAdapterModule } from './customOneStoreAdapter';
+export { subscribeToAdapter, invokeAdapter, invokeAdapterWithMetadata, invokeAdapterWithDraftToReplace, invokeAdapterWithDraftToMerge, executeAdapter, executeMutatingAdapter, nimbusDraftQueue, draftQueue, draftManager, setUiApiRecordTTL, setMetadataTTL, registerReportObserver, getImperativeAdapterNames, createPrimingSession, evictCacheRecordsByIds, evictExpiredCacheEntries, stopEviction, importLuvioAdapterModule, importOneStoreAdapterModule, };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-worker-api",
-    "version": "1.371.0",
+    "version": "1.372.1",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "",
     "main": "dist/standalone/es/lds-worker-api.js",
@@ -35,14 +35,14 @@
     },
     "devDependencies": {
         "@oat-sa/rollup-plugin-wildcard-external": "^1.0.0",
-        "@salesforce/lds-adapters-graphql": "^1.371.0",
-        "@salesforce/lds-adapters-uiapi": "^1.371.0",
-        "@salesforce/lds-default-luvio": "^1.371.0",
-        "@salesforce/lds-drafts": "^1.371.0",
-        "@salesforce/lds-graphql-parser": "^1.371.0",
-        "@salesforce/lds-luvio-engine": "^1.371.0",
-        "@salesforce/lds-runtime-mobile": "^1.371.0",
-        "@salesforce/nimbus-plugin-lds": "^1.371.0",
+        "@salesforce/lds-adapters-graphql": "^1.372.1",
+        "@salesforce/lds-adapters-uiapi": "^1.372.1",
+        "@salesforce/lds-default-luvio": "^1.372.1",
+        "@salesforce/lds-drafts": "^1.372.1",
+        "@salesforce/lds-graphql-parser": "^1.372.1",
+        "@salesforce/lds-luvio-engine": "^1.372.1",
+        "@salesforce/lds-runtime-mobile": "^1.372.1",
+        "@salesforce/nimbus-plugin-lds": "^1.372.1",
         "ajv": "^8.11.0",
         "glob": "^7.1.5",
         "nimbus-types": "^2.0.0-alpha1",
@@ -54,8 +54,8 @@
         {
             "path": "./dist/sfdc/es/ldsWorkerApi.js",
             "maxSize": {
-                "none": "50 kB",
-                "min": "21.0 kB",
+                "none": "55 kB",
+                "min": "23 kB",
                 "compressed": "9 kB"
             }
         }