@sanity/core-loader - npm Package Compare versions

Comparing version 0.1.7-pink-lizard to 0.1.8-pink-lizard

CHANGELOG.md

 # Changelog
 
+## [0.1.8-pink-lizard](https://github.com/sanity-io/visual-editing/compare/core-loader-v0.1.7-pink-lizard...core-loader-v0.1.8-pink-lizard) (2023-10-23)
+
+
+### Bug Fixes
+
+* disable minification to ease debugging ([666f8e0](https://github.com/sanity-io/visual-editing/commit/666f8e07565a566291c7a19b7dfe65a12aed49a5))
+* track studio origin ([209d5f2](https://github.com/sanity-io/visual-editing/commit/209d5f24a38c9dbbe21c882043bcd9ae177321a8))
+
 ## [0.1.7-pink-lizard](https://github.com/sanity-io/visual-editing/compare/core-loader-v0.1.6-pink-lizard...core-loader-v0.1.7-pink-lizard) (2023-10-23)
@@ -4,0 +12,0 @@

dist/index.d.ts

@@ -62,2 +62,3 @@ import type { ContentSourceMap } from '@sanity/client'
   connected: boolean
+  studioOrigin: string
 }
@@ -64,0 +65,0 @@

dist/index.js

@@ -1,1 +0,941 @@
-let e=0,t=[];let n=Symbol("clean"),r=[],s=(e,t)=>{let s=[],o={get:()=>(o.lc||o.listen((()=>{}))(),o.value),l:t||0,lc:0,listen:(e,t)=>(o.lc=s.push(e,t||o.l)/2,()=>{let t=s.indexOf(e);~t&&(s.splice(t,2),--o.lc||o.off())}),notify(e){let t=!r.length;for(let t=0;t<s.length;t+=2)r.push(s[t],s[t+1],o.value,e);if(t){for(let e=0;e<r.length;e+=4){let t;for(let n=e+1;!t&&(n+=4)<r.length;)r[n]<r[e+1]&&(t=r.push(r[e],r[e+1],r[e+2],r[e+3]));t||r[e](r[e+2],r[e+3])}r.length=0}},off(){},set(e){o.value!==e&&(o.value=e,o.notify())},subscribe(e,t){let n=o.listen(e,t);return e(o.value),n},value:e};return"production"!==process.env.NODE_ENV&&(o[n]=()=>{s=[],o.lc=0,o.off()}),o};let o=(e,t,n,r)=>(e.events=e.events||{},e.events[n+10]||(e.events[n+10]=r((t=>{e.events[n].reduceRight(((e,t)=>(t(e),e)),{shared:{},...t})}))),e.events[n]=e.events[n]||[],e.events[n].push(t),()=>{let r=e.events[n],s=r.indexOf(t);r.splice(s,1),r.length||(delete e.events[n],e.events[n+10](),delete e.events[n+10])}),a=(e,t)=>o(e,t,0,(t=>{let n=e.listen;return e.listen=r=>(e.lc||e.starting||(e.starting=!0,t(),delete e.starting),n(r)),()=>{e.listen=n}})),c=(e,t)=>o(e,t,1,(t=>{let n=e.off;return e.off=()=>{t(),n()},()=>{e.off=n}})),i=(e,t)=>o(e,(n=>{let r=t(n);r&&e.events[6].push(r)}),5,(t=>{let r=e.listen;e.listen=(...n)=>(e.lc||e.active||(e.active=!0,t()),r(...n));let s=e.off;if(e.events[6]=[],e.off=()=>{s(),setTimeout((()=>{if(e.active&&!e.lc){e.active=!1;for(let t of e.events[6])t();e.events[6]=[]}}),1e3)},"production"!==process.env.NODE_ENV){let t=e[n];e[n]=()=>{for(let t of e.events[6])t();e.events[6]=[],e.active=!1,t()}}return()=>{e.listen=r,e.off=s}}));let l=(e={})=>{let t=s(e);return t.setKey=function(e,n){void 0===n?e in t.value&&(t.value={...t.value},delete t.value[e],t.notify(e)):t.value[e]!==n&&(t.value={...t.value,[e]:n},t.notify(e))},t},u=()=>({events:{},emit(e,...t){let n=this.events[e]||[];for(let e=0,r=n.length;e<r;e++)n[e](...t)},on(e,t){return this.events[e]?.push(t)||(this.events[e]=[t]),()=>{this.events[e]=this.events[e]?.filter((e=>t!==e))}}});const d=({cache:n=new Map,fetcher:r,...s}={})=>{const o=u();let i=!0;m("visibilitychange",(()=>{i=!document.hidden,i&&o.emit(p)})),m("online",(()=>o.emit(v)));const d=new Map,f=new Map,O=new Map;let S={};const M=async([r,s],a,c,l)=>{var u;if(!i)return;const d=e=>{a.key===r&&(a.set(e),o.emit(g,r,e,!0))},h=()=>{d({...a.value,...b,promise:O.get(r)})},{dedupeTime:p=4e3,fetcher:v}={...c,...S},y=E();if(O.has(r))return void(a.value.loading||h());if(!l){const e=n.get(r);e&&a.value.data!==e&&d({data:e,...k});const t=f.get(r);if(t&&t+p>y)return}const m=(e+=1,()=>{if(e-=1,0===e){let e=t;t=[];for(let t of e)t()}});try{const e=v(...s);f.set(r,y),O.set(r,e),h();const t=await e;n.set(r,t),d({data:t,...k}),f.set(r,E())}catch(e){null==(u=c.onError)||u.call(c,e),d({data:a.value.data,error:e,...k})}finally{m(),O.delete(r)}},K=e=>{n.delete(e),f.delete(e)},N=(e,t)=>{for(const r of n.keys())w(r,e)&&t(r)},I=e=>{N(e,K),o.emit(y,e)},U=(e,t)=>{N(e,(e=>{void 0===t?K(e):n.set(e,t)})),o.emit(g,e,t)};return[(e,{fetcher:t=r,...n}={})=>{if("production"!==process.env.NODE_ENV&&!t)throw new Error("You need to set up either global fetcher of fetcher in createFetcherStore");const i=l({...k}),u={...s,...n,fetcher:t};let f,m,E,b,O;i.invalidate=()=>{const{key:e}=i;e&&I(e)},i.mutate=e=>{const{key:t}=i;t&&U(t,e)};let S=[];a(i,(()=>{const t=!f;[O,f]=h(e),b=O.subscribe((e=>{if(e){const[t,n]=e;i.key=t,M([t,n],i,u),m=t,E=n}else i.key=m=E=void 0}));const n=O.get();n&&([m,E]=n,t&&K());const{refetchInterval:r=0,refetchOnFocus:s,refetchOnReconnect:a}=u,c=()=>{m&&M([m,E],i,u)};r>0&&d.set(e,setInterval(c,r)),s&&S.push(o.on(p,c)),a&&S.push(o.on(v,c)),S.push(o.on(y,(e=>{m&&w(m,e)&&M([m,E],i,u,!0)})),o.on(g,((e,t,n)=>{m&&w(m,e)&&i.value!==t&&i.value.data!==t&&i.set(n?t:{data:t,...k})})))}));const K=()=>{m&&E&&M([m,E],i,u)},N=i.listen;return i.listen=e=>{const t=N(e);return e(i.value),K(),t},c(i,(()=>{i.value={...k},null==f||f(),S.forEach((e=>e())),S=[],null==b||b();const t=d.get(e);t&&clearInterval(t)})),i},function(e){const t=async o=>{var a,c;const i=null!=(a=S.fetcher)?a:e,l=[];try{r.set({error:void 0,data:void 0,mutate:t,...b});const e=await i({data:o,invalidate:e=>{l.push(e)},getCacheUpdater:(e,t=!0)=>[n=>{U(e,n),t&&l.push(e)},n.get(e)]});return r.setKey("data",e),e}catch(e){null==(c=null==s?void 0:s.onError)||c.call(s,e),r.setKey("error",e)}finally{r.setKey("loading",!1),l.forEach(I)}},r=l({mutate:t,...k});return r.mutate=t,r},{__unsafeOverruleSettings:e=>{"test"!==process.env.NODE_ENV&&console.warn("You should only use __unsafeOverruleSettings in test environment"),S=e},invalidateKeys:I,mutateCache:U}]};function f(e){return"string"==typeof e||"number"==typeof e}const h=e=>{if(f(e))return[s([""+e,[e]]),()=>{}];let t=s(null),n=[];const r=()=>{n.some((e=>null==e))?t.set(null):t.set([n.join(""),n])},o=[];for(let t=0;t<e.length;t++){const s=e[t];f(s)?n.push(s):o.push(s.subscribe((e=>{n[t]=e,r()})))}return r(),[t,()=>o.forEach((e=>e()))]},p=1,v=2,y=3,g=4,m=(e,t)=>{"undefined"==typeof window||addEventListener(e,t)},w=(e,t)=>Array.isArray(t)?t.includes(e):"function"==typeof t?t(e):e===t,E=()=>(new Date).getTime(),b={loading:!0},k={loading:!1};let O;const S=new Uint8Array(16);function M(){if(!O&&(O="undefined"!=typeof crypto&&crypto.getRandomValues&&crypto.getRandomValues.bind(crypto),!O))throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");return O(S)}const K=[];for(let e=0;e<256;++e)K.push((e+256).toString(16).slice(1));var N={randomUUID:"undefined"!=typeof crypto&&crypto.randomUUID&&crypto.randomUUID.bind(crypto)};function I(e,t,n){if(N.randomUUID&&!t&&!e)return N.randomUUID();const r=(e=e||{}).random||(e.rng||M)();if(r[6]=15&r[6]|64,r[8]=63&r[8]|128,t){n=n||0;for(let e=0;e<16;++e)t[n+e]=r[e];return t}return function(e,t=0){return K[e[t+0]]+K[e[t+1]]+K[e[t+2]]+K[e[t+3]]+"-"+K[e[t+4]]+K[e[t+5]]+"-"+K[e[t+6]]+K[e[t+7]]+"-"+K[e[t+8]]+K[e[t+9]]+"-"+K[e[t+10]]+K[e[t+11]]+K[e[t+12]]+K[e[t+13]]+K[e[t+14]]+K[e[t+15]]}(r)}const U=["channel/disconnect","channel/response","handshake/syn","handshake/syn-ack","handshake/ack"],j=e=>U.some((t=>t===e));function D(e){const{connections:t,handler:n}=e,r=e.id||I(),s=window.self!==window.top,o=[],a=[];function c(e){return function(t){return t.id===e.id&&t.target===e.target}}function i(t,n=!0){const r=o.findIndex(c(t));n&&r<0?(o.push(t),e.onConnect?.(t),function(){const e=[...a];a.splice(0,a.length),e.forEach((({connection:e,type:t,data:n})=>{u(e,t,n)}))}()):!n&&r&&(o.splice(r,1),e.onDisconnect?.(t))}function l(e){const{source:n,origin:s,data:o}=e;if(a=o,Boolean(a)&&"object"==typeof a&&!Array.isArray(a))return t.find((e=>o.to===r&&e.id===o.from&&e.target===n&&(e.targetOrigin===s||"*"===e.targetOrigin)));var a}function u(e,t,n){const s={id:I(),type:t,from:r,to:e.id,data:n},i=j(t),l=o.find(c(e));if(i||l){const t=i?"*":e.targetOrigin;try{return e.target.postMessage(s,{targetOrigin:t})}catch(t){console.error("Failed to postMessage",t,{msg:s,connection:e})}}!function(e){a.push(e)}({connection:e,type:t,data:n})}function d(e,t,n){return e.forEach((e=>{u(e,t,n)}))}function f(e){const t=l(e);if(!t)return;const{data:r}=e;if(s=r.type,j(s)&&s.startsWith("handshake/"))!function(e,t){"handshake/syn"===t.data.type&&u(e,"handshake/syn-ack"),"handshake/syn-ack"===t.data.type&&(i(e,!0),u(e,"handshake/ack")),"handshake/ack"===t.data.type&&i(e,!0)}(t,e);else if("channel/disconnect"===r.type)i(t,!1);else if("channel/response"===r.type);else{const e=[r.type,r.data];n(...e),u(t,"channel/response")}var s}return window.addEventListener("message",f,!1),d(t,"handshake/syn"),{disconnect:function(){window.removeEventListener("message",f,!1),o.length&&(d(o,"channel/disconnect"),o.forEach((e=>{i(e,!1)})))},inFrame:s,send:function(e,n){return new Promise((r=>{const s=e=>{const{data:t}=e;"channel/response"===t.type&&(window.removeEventListener("message",s,!1),r())};window.addEventListener("message",s,!1),d(t,e,n)}))}}}function q(e,t){return`${e}-${"string"==typeof t?t:JSON.stringify(t)}`}const A=e=>{const{client:t,studioUrl:n}=e,{projectId:r,dataset:o,resultSourceMap:u}=t.config();if(!r)throw new Error("Missing projectId");if(!o)throw new Error("Missing dataset");u||t.config({resultSourceMap:"withKeyArraySelector"});const f=l({enabled:!1,connected:!1}),h=l({});let p=null;const v=new Map,[y,g,{mutateCache:m}]=d({cache:v,fetcher:async(...e)=>{if(v.has(e.join("")))return v.get(e.join(""));const[n,s]=e,a=s?JSON.parse(s):{};if(f.get().enabled){if(!p)throw new Error("No channel");p.send("loader/query-listen",{projectId:r,dataset:o,query:n,params:a})}const{result:c,resultSourceMap:i}=await t.fetch(n,a,{filterResponse:!1});return f.get().enabled&&h.setKey(q(n,a),i?.documents),{query:n,params:a,result:c,resultSourceMap:i}}}),w=l({}),E=((e,t)=>{let n;Array.isArray(e)||(e=[e]);let r=()=>{let r=e.map((e=>e.get()));(void 0===n||r.some(((e,t)=>e!==n[t])))&&(n=r,o.set(t(...r)))},o=s(void 0,Math.max(...e.map((e=>e.l)))+1);return i(o,(()=>{let t=e.map((e=>e.listen(r,o.l)));return r(),()=>{for(let e of t)e()}})),o})([h,w],((e,t)=>{const n=Object.values(t).filter((e=>!!e?.listeners&&e.listeners>0)),r=[];for(const{query:t,params:s}of n){const n=q(t,s);e[n]&&r.push(...e[n])}return r})),b=s(!1);return i(f,(()=>{f.setKey("enabled",!0),p=D({id:"loaders",onConnect:()=>{f.setKey("connected",!0)},onDisconnect:()=>{f.setKey("connected",!1)},connections:[{target:parent,targetOrigin:n,id:"composer"}],handler:(e,t)=>{if("loader/query-change"===e&&t.projectId===r&&t.dataset===o){const e=[t.query,JSON.stringify(t.params)].join(""),n=v.has(e)?v.get(e):{};m(e,{query:t.query,params:t.params,result:t.result,resultSourceMap:t.resultSourceMap||n.resultSourceMap})}"loader/ping"===e&&b.set(!0)}});const e=b.subscribe((e=>{p&&e&&(p.send("loader/pong",void 0),b.set(!1))})),t=function(e,t,n){let r=new Set([...t,void 0]);return e.listen(((e,t)=>{r.has(t)&&n(e,t)}))}(f,["connected"],(()=>{})),s=E.subscribe((e=>{if(!p)throw new Error("No channel");p.send("loader/documents",{projectId:r,dataset:o,documents:e})}));return()=>{e(),s(),t(),f.setKey("enabled",!1),f.setKey("connected",!1),p?.disconnect(),p=null}})),{createFetcherStore:(e,t)=>{const n=y(e,t);return a(n,(()=>{const[t,n]=e,r=n?JSON.parse(n):{},s=q(t,r),o=w.get()[s],a=o?.listeners||0;w.setKey(s,{...o,query:t,params:r,listeners:a+1})})),c(n,(()=>{const[t,n]=e,r=n?JSON.parse(n):{},s=q(t,r),o=w.get()[s],a=o?.listeners||1;a>1?w.setKey(s,{...o,query:t,params:r,listeners:a-1}):w.setKey(s,void 0)})),n},$LiveMode:f}};export{A as createQueryStore};//# sourceMappingURL=index.js.map
+let tasks = 0;
+let resolves = [];
+function startTask() {
+  tasks += 1;
+  return () => {
+    tasks -= 1;
+    if (tasks === 0) {
+      let prevResolves = resolves;
+      resolves = [];
+      for (let i of prevResolves) i();
+    }
+  };
+}
+let clean = Symbol('clean');
+let listenerQueue = [];
+let atom = (initialValue, level) => {
+  let listeners = [];
+  let $atom = {
+    get() {
+      if (!$atom.lc) {
+        $atom.listen(() => {})();
+      }
+      return $atom.value;
+    },
+    l: level || 0,
+    lc: 0,
+    listen(listener, listenerLevel) {
+      $atom.lc = listeners.push(listener, listenerLevel || $atom.l) / 2;
+      return () => {
+        let index = listeners.indexOf(listener);
+        if (~index) {
+          listeners.splice(index, 2);
+          if (! --$atom.lc) $atom.off();
+        }
+      };
+    },
+    notify(changedKey) {
+      let runListenerQueue = !listenerQueue.length;
+      for (let i = 0; i < listeners.length; i += 2) {
+        listenerQueue.push(listeners[i], listeners[i + 1], $atom.value, changedKey);
+      }
+      if (runListenerQueue) {
+        for (let i = 0; i < listenerQueue.length; i += 4) {
+          let skip;
+          for (let j = i + 1; !skip && (j += 4) < listenerQueue.length;) {
+            if (listenerQueue[j] < listenerQueue[i + 1]) {
+              skip = listenerQueue.push(listenerQueue[i], listenerQueue[i + 1], listenerQueue[i + 2], listenerQueue[i + 3]);
+            }
+          }
+          if (!skip) {
+            listenerQueue[i](listenerQueue[i + 2], listenerQueue[i + 3]);
+          }
+        }
+        listenerQueue.length = 0;
+      }
+    },
+    off() {},
+    /* It will be called on last listener unsubscribing.
+       We will redefine it in onMount and onStop. */
+    set(data) {
+      if ($atom.value !== data) {
+        $atom.value = data;
+        $atom.notify();
+      }
+    },
+    subscribe(listener, listenerLevel) {
+      let unbind = $atom.listen(listener, listenerLevel);
+      listener($atom.value);
+      return unbind;
+    },
+    value: initialValue
+  };
+  if (process.env.NODE_ENV !== 'production') {
+    $atom[clean] = () => {
+      listeners = [];
+      $atom.lc = 0;
+      $atom.off();
+    };
+  }
+  return $atom;
+};
+const START = 0;
+const STOP = 1;
+const MOUNT = 5;
+const UNMOUNT = 6;
+const REVERT_MUTATION = 10;
+let on = (object, listener, eventKey, mutateStore) => {
+  object.events = object.events || {};
+  if (!object.events[eventKey + REVERT_MUTATION]) {
+    object.events[eventKey + REVERT_MUTATION] = mutateStore(eventProps => {
+      // eslint-disable-next-line no-sequences
+      object.events[eventKey].reduceRight((event, l) => (l(event), event), {
+        shared: {},
+        ...eventProps
+      });
+    });
+  }
+  object.events[eventKey] = object.events[eventKey] || [];
+  object.events[eventKey].push(listener);
+  return () => {
+    let currentListeners = object.events[eventKey];
+    let index = currentListeners.indexOf(listener);
+    currentListeners.splice(index, 1);
+    if (!currentListeners.length) {
+      delete object.events[eventKey];
+      object.events[eventKey + REVERT_MUTATION]();
+      delete object.events[eventKey + REVERT_MUTATION];
+    }
+  };
+};
+let onStart = ($store, listener) => on($store, listener, START, runListeners => {
+  let originListen = $store.listen;
+  $store.listen = arg => {
+    if (!$store.lc && !$store.starting) {
+      $store.starting = true;
+      runListeners();
+      delete $store.starting;
+    }
+    return originListen(arg);
+  };
+  return () => {
+    $store.listen = originListen;
+  };
+});
+let onStop = ($store, listener) => on($store, listener, STOP, runListeners => {
+  let originOff = $store.off;
+  $store.off = () => {
+    runListeners();
+    originOff();
+  };
+  return () => {
+    $store.off = originOff;
+  };
+});
+let STORE_UNMOUNT_DELAY = 1000;
+let onMount = ($store, initialize) => {
+  let listener = payload => {
+    let destroy = initialize(payload);
+    if (destroy) $store.events[UNMOUNT].push(destroy);
+  };
+  return on($store, listener, MOUNT, runListeners => {
+    let originListen = $store.listen;
+    $store.listen = (...args) => {
+      if (!$store.lc && !$store.active) {
+        $store.active = true;
+        runListeners();
+      }
+      return originListen(...args);
+    };
+    let originOff = $store.off;
+    $store.events[UNMOUNT] = [];
+    $store.off = () => {
+      originOff();
+      setTimeout(() => {
+        if ($store.active && !$store.lc) {
+          $store.active = false;
+          for (let destroy of $store.events[UNMOUNT]) destroy();
+          $store.events[UNMOUNT] = [];
+        }
+      }, STORE_UNMOUNT_DELAY);
+    };
+    if (process.env.NODE_ENV !== 'production') {
+      let originClean = $store[clean];
+      $store[clean] = () => {
+        for (let destroy of $store.events[UNMOUNT]) destroy();
+        $store.events[UNMOUNT] = [];
+        $store.active = false;
+        originClean();
+      };
+    }
+    return () => {
+      $store.listen = originListen;
+      $store.off = originOff;
+    };
+  });
+};
+let computed = (stores, cb) => {
+  if (!Array.isArray(stores)) stores = [stores];
+  let diamondArgs;
+  let run = () => {
+    let args = stores.map($store => $store.get());
+    if (diamondArgs === undefined || args.some((arg, i) => arg !== diamondArgs[i])) {
+      diamondArgs = args;
+      $computed.set(cb(...args));
+    }
+  };
+  let $computed = atom(undefined, Math.max(...stores.map(s => s.l)) + 1);
+  onMount($computed, () => {
+    let unbinds = stores.map($store => $store.listen(run, $computed.l));
+    run();
+    return () => {
+      for (let unbind of unbinds) unbind();
+    };
+  });
+  return $computed;
+};
+function listenKeys($store, keys, listener) {
+  let keysSet = new Set([...keys, undefined]);
+  return $store.listen((value, changed) => {
+    if (keysSet.has(changed)) {
+      listener(value, changed);
+    }
+  });
+}
+let map = (value = {}) => {
+  let $map = atom(value);
+  $map.setKey = function (key, newValue) {
+    if (typeof newValue === 'undefined') {
+      if (key in $map.value) {
+        $map.value = {
+          ...$map.value
+        };
+        delete $map.value[key];
+        $map.notify(key);
+      }
+    } else if ($map.value[key] !== newValue) {
+      $map.value = {
+        ...$map.value,
+        [key]: newValue
+      };
+      $map.notify(key);
+    }
+  };
+  return $map;
+};
+let createNanoEvents = () => ({
+  events: {},
+  emit(event, ...args) {
+    let callbacks = this.events[event] || [];
+    for (let i = 0, length = callbacks.length; i < length; i++) {
+      callbacks[i](...args);
+    }
+  },
+  on(event, cb) {
+    this.events[event]?.push(cb) || (this.events[event] = [cb]);
+    return () => {
+      this.events[event] = this.events[event]?.filter(i => cb !== i);
+    };
+  }
+});
+const nanoquery = ({
+  cache = /* @__PURE__ */new Map(),
+  fetcher: globalFetcher,
+  ...globalSettings
+} = {}) => {
+  const events = createNanoEvents();
+  let focus = true;
+  subscribe("visibilitychange", () => {
+    focus = !document.hidden;
+    focus && events.emit(FOCUS);
+  });
+  subscribe("online", () => events.emit(RECONNECT));
+  const _refetchOnInterval = /* @__PURE__ */new Map(),
+    _lastFetch = /* @__PURE__ */new Map(),
+    _runningFetches = /* @__PURE__ */new Map();
+  let rewrittenSettings = {};
+  const runFetcher = async ([key, keyParts], store, settings, force) => {
+    var _a;
+    if (!focus) return;
+    const set = v => {
+      if (store.key === key) {
+        store.set(v);
+        events.emit(SET_CACHE, key, v, true);
+      }
+    };
+    const setAsLoading = () => {
+      set({
+        ...store.value,
+        ...loading,
+        promise: _runningFetches.get(key)
+      });
+    };
+    const {
+      dedupeTime = 4e3,
+      fetcher
+    } = {
+      ...settings,
+      ...rewrittenSettings
+    };
+    const now = getNow();
+    if (_runningFetches.has(key)) {
+      if (!store.value.loading) setAsLoading();
+      return;
+    }
+    if (!force) {
+      const cached = cache.get(key);
+      if (cached && store.value.data !== cached) set({
+        data: cached,
+        ...notLoading
+      });
+      const last = _lastFetch.get(key);
+      if (last && last + dedupeTime > now) {
+        return;
+      }
+    }
+    const finishTask = startTask();
+    try {
+      const promise = fetcher(...keyParts);
+      _lastFetch.set(key, now);
+      _runningFetches.set(key, promise);
+      setAsLoading();
+      const res = await promise;
+      cache.set(key, res);
+      set({
+        data: res,
+        ...notLoading
+      });
+      _lastFetch.set(key, getNow());
+    } catch (error) {
+      (_a = settings.onError) == null ? void 0 : _a.call(settings, error);
+      set({
+        data: store.value.data,
+        error,
+        ...notLoading
+      });
+    } finally {
+      finishTask();
+      _runningFetches.delete(key);
+    }
+  };
+  const createFetcherStore = (keyInput, {
+    fetcher = globalFetcher,
+    ...fetcherSettings
+  } = {}) => {
+    if (process.env.NODE_ENV !== "production" && !fetcher) {
+      throw new Error("You need to set up either global fetcher of fetcher in createFetcherStore");
+    }
+    const fetcherStore = map({
+        ...notLoading
+      }),
+      settings = {
+        ...globalSettings,
+        ...fetcherSettings,
+        fetcher
+      };
+    fetcherStore.invalidate = () => {
+      const {
+        key
+      } = fetcherStore;
+      if (key) {
+        invalidateKeys(key);
+      }
+    };
+    fetcherStore.mutate = data => {
+      const {
+        key
+      } = fetcherStore;
+      if (key) {
+        mutateCache(key, data);
+      }
+    };
+    let keysInternalUnsub, prevKey, prevKeyParts, keyUnsub, keyStore;
+    let evtUnsubs = [];
+    onStart(fetcherStore, () => {
+      const firstRun = !keysInternalUnsub;
+      [keyStore, keysInternalUnsub] = getKeyStore(keyInput);
+      keyUnsub = keyStore.subscribe(currentKeys => {
+        if (currentKeys) {
+          const [newKey, keyParts] = currentKeys;
+          fetcherStore.key = newKey;
+          runFetcher([newKey, keyParts], fetcherStore, settings);
+          prevKey = newKey;
+          prevKeyParts = keyParts;
+        } else {
+          fetcherStore.key = prevKey = prevKeyParts = void 0;
+        }
+      });
+      const currentKeyValue = keyStore.get();
+      if (currentKeyValue) {
+        [prevKey, prevKeyParts] = currentKeyValue;
+        if (firstRun) handleNewListener();
+      }
+      const {
+        refetchInterval = 0,
+        refetchOnFocus,
+        refetchOnReconnect
+      } = settings;
+      const runRefetcher = () => {
+        if (prevKey) runFetcher([prevKey, prevKeyParts], fetcherStore, settings);
+      };
+      if (refetchInterval > 0) {
+        _refetchOnInterval.set(keyInput, setInterval(runRefetcher, refetchInterval));
+      }
+      if (refetchOnFocus) evtUnsubs.push(events.on(FOCUS, runRefetcher));
+      if (refetchOnReconnect) evtUnsubs.push(events.on(RECONNECT, runRefetcher));
+      evtUnsubs.push(events.on(INVALIDATE_KEYS, keySelector => {
+        if (prevKey && testKeyAgainstSelector(prevKey, keySelector)) {
+          runFetcher([prevKey, prevKeyParts], fetcherStore, settings, true);
+        }
+      }), events.on(SET_CACHE, (keySelector, data, full) => {
+        if (prevKey && testKeyAgainstSelector(prevKey, keySelector) && fetcherStore.value !== data && fetcherStore.value.data !== data) {
+          fetcherStore.set(full ? data : {
+            data,
+            ...notLoading
+          });
+        }
+      }));
+    });
+    const handleNewListener = () => {
+      if (prevKey && prevKeyParts) runFetcher([prevKey, prevKeyParts], fetcherStore, settings);
+    };
+    const originListen = fetcherStore.listen;
+    fetcherStore.listen = listener => {
+      const unsub = originListen(listener);
+      listener(fetcherStore.value);
+      handleNewListener();
+      return unsub;
+    };
+    onStop(fetcherStore, () => {
+      fetcherStore.value = {
+        ...notLoading
+      };
+      keysInternalUnsub == null ? void 0 : keysInternalUnsub();
+      evtUnsubs.forEach(fn => fn());
+      evtUnsubs = [];
+      keyUnsub == null ? void 0 : keyUnsub();
+      const int = _refetchOnInterval.get(keyInput);
+      if (int) clearInterval(int);
+    });
+    return fetcherStore;
+  };
+  const nukeKey = key => {
+    cache.delete(key);
+    _lastFetch.delete(key);
+  };
+  const iterOverCache = (keySelector, cb) => {
+    for (const key of cache.keys()) {
+      if (testKeyAgainstSelector(key, keySelector)) cb(key);
+    }
+  };
+  const invalidateKeys = keySelector => {
+    iterOverCache(keySelector, nukeKey);
+    events.emit(INVALIDATE_KEYS, keySelector);
+  };
+  const mutateCache = (keySelector, data) => {
+    iterOverCache(keySelector, key => {
+      if (data === void 0) nukeKey(key);else cache.set(key, data);
+    });
+    events.emit(SET_CACHE, keySelector, data);
+  };
+  function createMutatorStore(mutator) {
+    const mutate = async data => {
+      var _a, _b;
+      const newMutator = (_a = rewrittenSettings.fetcher) != null ? _a : mutator;
+      const keysToInvalidate = [];
+      try {
+        store.set({
+          error: void 0,
+          data: void 0,
+          mutate,
+          ...loading
+        });
+        const result = await newMutator({
+          data,
+          invalidate: key => {
+            keysToInvalidate.push(key);
+          },
+          getCacheUpdater: (key, shouldInvalidate = true) => [newVal => {
+            mutateCache(key, newVal);
+            if (shouldInvalidate) {
+              keysToInvalidate.push(key);
+            }
+          }, cache.get(key)]
+        });
+        store.setKey("data", result);
+        return result;
+      } catch (error) {
+        (_b = globalSettings == null ? void 0 : globalSettings.onError) == null ? void 0 : _b.call(globalSettings, error);
+        store.setKey("error", error);
+      } finally {
+        store.setKey("loading", false);
+        keysToInvalidate.forEach(invalidateKeys);
+      }
+    };
+    const store = map({
+      mutate,
+      ...notLoading
+    });
+    store.mutate = mutate;
+    return store;
+  }
+  const __unsafeOverruleSettings = data => {
+    if (process.env.NODE_ENV !== "test") {
+      console.warn(`You should only use __unsafeOverruleSettings in test environment`);
+    }
+    rewrittenSettings = data;
+  };
+  return [createFetcherStore, createMutatorStore, {
+    __unsafeOverruleSettings,
+    invalidateKeys,
+    mutateCache
+  }];
+};
+function isSomeKey(key) {
+  return typeof key === "string" || typeof key === "number";
+}
+const getKeyStore = keys => {
+  if (isSomeKey(keys)) return [atom(["" + keys, [keys]]), () => {}];
+  let keyStore = atom(null),
+    keyParts = [];
+  const setKeyStoreValue = () => {
+    if (keyParts.some(v => v === null || v === void 0)) {
+      keyStore.set(null);
+    } else {
+      keyStore.set([keyParts.join(""), keyParts]);
+    }
+  };
+  const unsubs = [];
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    if (isSomeKey(key)) {
+      keyParts.push(key);
+      continue;
+    }
+    unsubs.push(key.subscribe(newValue => {
+      keyParts[i] = newValue;
+      setKeyStoreValue();
+    }));
+  }
+  setKeyStoreValue();
+  return [keyStore, () => unsubs.forEach(fn => fn())];
+};
+const FOCUS = 1,
+  RECONNECT = 2,
+  INVALIDATE_KEYS = 3,
+  SET_CACHE = 4;
+const subscribe = (name, fn) => {
+  const isServer = typeof window === "undefined";
+  if (!isServer) {
+    addEventListener(name, fn);
+  }
+};
+const testKeyAgainstSelector = (key, selector) => {
+  if (Array.isArray(selector)) return selector.includes(key);else if (typeof selector === "function") return selector(key);else return key === selector;
+};
+const getNow = () => new Date().getTime();
+const loading = {
+    loading: true
+  },
+  notLoading = {
+    loading: false
+  };
+
+// Unique ID creation requires a high quality random # generator. In the browser we therefore
+// require the crypto API and do not support built-in fallback to lower quality random number
+// generators (like Math.random()).
+let getRandomValues;
+const rnds8 = new Uint8Array(16);
+function rng() {
+  // lazy load so that environments that need to polyfill have a chance to do so
+  if (!getRandomValues) {
+    // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation.
+    getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto);
+    if (!getRandomValues) {
+      throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
+    }
+  }
+  return getRandomValues(rnds8);
+}
+
+/**
+ * Convert array of 16 byte values to UUID string format of the form:
+ * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+ */
+
+const byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 0x100).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+  // Note: Be careful editing this code!  It's been tuned for performance
+  // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
+  return byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]];
+}
+const randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);
+var native = {
+  randomUUID
+};
+function v4(options, buf, offset) {
+  if (native.randomUUID && !buf && !options) {
+    return native.randomUUID();
+  }
+  options = options || {};
+  const rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
+
+  rnds[6] = rnds[6] & 0x0f | 0x40;
+  rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided
+
+  if (buf) {
+    offset = offset || 0;
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+const INTERNAL_MSG_TYPES = ["channel/disconnect", "channel/response", "handshake/syn", "handshake/syn-ack", "handshake/ack"];
+const isObject = value => {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+};
+const isInternalMessage = type => {
+  return INTERNAL_MSG_TYPES.some(t => t === type);
+};
+const isHandshake = type => isInternalMessage(type) && type.startsWith("handshake/");
+function createChannel(config) {
+  const {
+    connections,
+    handler
+  } = config;
+  const clientId = config.id || v4();
+  const inFrame = window.self !== window.top;
+  const activeConnections = [];
+  const messageBuffer = [];
+  function addToBuffer(msg) {
+    messageBuffer.push(msg);
+  }
+  function flush() {
+    const toFlush = [...messageBuffer];
+    messageBuffer.splice(0, messageBuffer.length);
+    toFlush.forEach(({
+      connection,
+      type,
+      data
+    }) => {
+      post(connection, type, data);
+    });
+  }
+  function connectionIsActive(connection) {
+    return function (activeConnection) {
+      return activeConnection.id === connection.id && activeConnection.target === connection.target;
+    };
+  }
+  function setConnectionState(connection, connected = true) {
+    const activeIndex = activeConnections.findIndex(connectionIsActive(connection));
+    if (connected && activeIndex < 0) {
+      activeConnections.push(connection);
+      config.onConnect?.(connection);
+      flush();
+    } else if (!connected && activeIndex) {
+      activeConnections.splice(activeIndex, 1);
+      config.onDisconnect?.(connection);
+    }
+  }
+  function findConnection(e) {
+    const {
+      source,
+      origin,
+      data
+    } = e;
+    if (isObject(data)) {
+      return connections.find(connection => data.to === clientId && connection.id === data.from && connection.target === source && (connection.targetOrigin === origin || connection.targetOrigin === "*"));
+    }
+    return void 0;
+  }
+  function post(connection, type, data) {
+    const msg = {
+      id: v4(),
+      type,
+      from: clientId,
+      to: connection.id,
+      data
+    };
+    const isInternal = isInternalMessage(type);
+    const activeConnection = activeConnections.find(connectionIsActive(connection));
+    if (isInternal || activeConnection) {
+      const targetOrigin = isInternal ? "*" : connection.targetOrigin;
+      try {
+        return connection.target.postMessage(msg, {
+          targetOrigin
+        });
+      } catch (e) {
+        console.error("Failed to postMessage", e, {
+          msg,
+          connection
+        });
+      }
+    }
+    addToBuffer({
+      connection,
+      type,
+      data
+    });
+  }
+  function postMany(connections2, type, data) {
+    return connections2.forEach(connection => {
+      post(connection, type, data);
+    });
+  }
+  function handleHandshake(connection, e) {
+    if (e.data.type === "handshake/syn") {
+      post(connection, "handshake/syn-ack");
+    }
+    if (e.data.type === "handshake/syn-ack") {
+      setConnectionState(connection, true);
+      post(connection, "handshake/ack");
+    }
+    if (e.data.type === "handshake/ack") {
+      setConnectionState(connection, true);
+    }
+  }
+  function handleEvents(e) {
+    const connection = findConnection(e);
+    if (!connection) return;
+    const {
+      data
+    } = e;
+    if (isHandshake(data.type)) {
+      handleHandshake(connection, e);
+    } else if (data.type === "channel/disconnect") {
+      setConnectionState(connection, false);
+    } else if (data.type === "channel/response") ;else {
+      const args = [data.type, data.data];
+      handler(...args);
+      post(connection, "channel/response");
+    }
+  }
+  function disconnect() {
+    window.removeEventListener("message", handleEvents, false);
+    if (!activeConnections.length) return;
+    postMany(activeConnections, "channel/disconnect");
+    activeConnections.forEach(connection => {
+      setConnectionState(connection, false);
+    });
+  }
+  function connect() {
+    window.addEventListener("message", handleEvents, false);
+    postMany(connections, "handshake/syn");
+  }
+  function send(type, data) {
+    return new Promise(resolve => {
+      const transact = e => {
+        const {
+          data: eventData
+        } = e;
+        if (eventData.type === "channel/response") {
+          window.removeEventListener("message", transact, false);
+          resolve();
+        }
+      };
+      window.addEventListener("message", transact, false);
+      postMany(connections, type, data);
+    });
+  }
+  connect();
+  return {
+    disconnect,
+    inFrame,
+    send
+  };
+}
+function getQueryCacheKey(query, params) {
+  return `${query}-${typeof params === "string" ? params : JSON.stringify(params)}`;
+}
+const createQueryStore = options => {
+  const {
+    client,
+    studioUrl
+  } = options;
+  const {
+    projectId,
+    dataset,
+    resultSourceMap
+  } = client.config();
+  if (!projectId) throw new Error("Missing projectId");
+  if (!dataset) throw new Error("Missing dataset");
+  if (!resultSourceMap) {
+    client.config({
+      resultSourceMap: "withKeyArraySelector"
+    });
+  }
+  const initialLiveMode = {
+    enabled: false,
+    connected: false,
+    studioOrigin: ""
+  };
+  const $LiveMode = map(initialLiveMode);
+  const $resultSourceMapDocuments = map({});
+  let channel = null;
+  const cache = /* @__PURE__ */new Map();
+  const [_createFetcherStore,
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  _createMutatorStore, {
+    mutateCache
+  }] = nanoquery({
+    // dedupeTime: DEDUPE_TIME,
+    // refetchOnFocus: REFETCH_ON_FOCUS,
+    // refetchOnReconnect: REFETCH_ON_RECONNECT,
+    // refetchInterval: REFETCH_INTERVAL,
+    cache,
+    fetcher: async (...keys) => {
+      if (cache.has(keys.join(""))) return cache.get(keys.join(""));
+      const [query, _params] = keys;
+      const params = _params ? JSON.parse(_params) : {};
+      if ($LiveMode.get().enabled) {
+        if (!channel) throw new Error("No channel");
+        channel.send("loader/query-listen", {
+          projectId,
+          dataset,
+          query,
+          params
+        });
+      }
+      const {
+        result,
+        resultSourceMap: resultSourceMap2
+      } = await client.fetch(query, params, {
+        filterResponse: false
+        // token: $token.get(),
+        // perspective: $perspective.get(),
+      });
+
+      if ($LiveMode.get().enabled) {
+        $resultSourceMapDocuments.setKey(getQueryCacheKey(query, params), resultSourceMap2?.documents);
+      }
+      return {
+        query,
+        params,
+        result,
+        resultSourceMap: resultSourceMap2
+      };
+    }
+  });
+  const $queriesInUse = map({});
+  const $documentsInUse = computed([$resultSourceMapDocuments, $queriesInUse], (resultSourceMapDocuments, _queriesInUse) => {
+    const queriesInUse = Object.values(_queriesInUse).filter(snapshot => snapshot?.listeners ? snapshot.listeners > 0 : false);
+    const documentsOnPage = [];
+    for (const {
+      query,
+      params
+    } of queriesInUse) {
+      const key = getQueryCacheKey(query, params);
+      if (resultSourceMapDocuments[key]) {
+        documentsOnPage.push(...resultSourceMapDocuments[key]);
+      }
+    }
+    return documentsOnPage;
+  });
+  const createFetcherStore = (keys, settings) => {
+    const $fetch = _createFetcherStore(keys, settings);
+    onStart($fetch, () => {
+      const [query, _params] = keys;
+      const params = _params ? JSON.parse(_params) : {};
+      const key = getQueryCacheKey(query, params);
+      const value = $queriesInUse.get()[key];
+      const listeners = value?.listeners || 0;
+      $queriesInUse.setKey(key, {
+        ...value,
+        query,
+        params,
+        listeners: listeners + 1
+      });
+    });
+    onStop($fetch, () => {
+      const [query, _params] = keys;
+      const params = _params ? JSON.parse(_params) : {};
+      const key = getQueryCacheKey(query, params);
+      const value = $queriesInUse.get()[key];
+      const listeners = value?.listeners || 1;
+      if (listeners > 1) {
+        $queriesInUse.setKey(key, {
+          ...value,
+          query,
+          params,
+          listeners: listeners - 1
+        });
+      } else {
+        $queriesInUse.setKey(key, void 0);
+      }
+    });
+    return $fetch;
+  };
+  const $shouldPong = atom(false);
+  onMount($LiveMode, () => {
+    $LiveMode.setKey("enabled", true);
+    const studioOrigin = new URL(studioUrl, location.origin).origin;
+    $LiveMode.setKey("studioOrigin", studioOrigin);
+    channel = createChannel({
+      id: "loaders",
+      onConnect: () => {
+        $LiveMode.setKey("connected", true);
+      },
+      onDisconnect: () => {
+        $LiveMode.setKey("connected", false);
+      },
+      connections: [{
+        target: parent,
+        targetOrigin: studioUrl,
+        id: "composer"
+      }],
+      handler: (type, data) => {
+        if (type === "loader/query-change" && data.projectId === projectId && data.dataset === dataset) {
+          const cacheKey = [data.query, JSON.stringify(data.params)].join("");
+          const prevCache = cache.has(cacheKey) ? cache.get(cacheKey) : {};
+          mutateCache(cacheKey, {
+            query: data.query,
+            params: data.params,
+            result: data.result,
+            // @TODO workaround limitation in live queries not sending source maps
+            resultSourceMap: data.resultSourceMap || prevCache.resultSourceMap
+          });
+        }
+        if (type === "loader/ping") {
+          $shouldPong.set(true);
+        }
+      }
+    });
+    const unlistenPong = $shouldPong.subscribe(shouldPong => {
+      if (channel && shouldPong) {
+        channel.send("loader/pong", void 0);
+        $shouldPong.set(false);
+      }
+    });
+    const unlistenConnection = listenKeys($LiveMode, ["connected"], () => {});
+    const unlistenQueries = $documentsInUse.subscribe(documents => {
+      if (!channel) {
+        throw new Error("No channel");
+      }
+      channel.send("loader/documents", {
+        projectId,
+        dataset,
+        documents
+      });
+    });
+    return () => {
+      unlistenPong();
+      unlistenQueries();
+      unlistenConnection();
+      $LiveMode.setKey("enabled", false);
+      $LiveMode.setKey("connected", false);
+      channel?.disconnect();
+      channel = null;
+    };
+  });
+  return {
+    createFetcherStore,
+    $LiveMode
+  };
+};
+export { createQueryStore };
+//# sourceMappingURL=index.js.map

package.json

 {
   "name": "@sanity/core-loader",
-  "version": "0.1.7-pink-lizard",
+  "version": "0.1.8-pink-lizard",
   "license": "MIT",
@@ -98,3 +98,3 @@ "author": "Sanity.io <[e-mail]>",
     "eslint-plugin-simple-import-sort": "^10.0.0",
-    "@sanity/groq-store": "0.0.5-pink-lizard",
+    "@sanity/groq-store": "0.0.6-pink-lizard",
     "channels": "0.0.0",
@@ -101,0 +101,0 @@ "visual-editing-helpers": "0.0.0"

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

249561

increased by52.37%

Lines of code

3044

increased by769.71%

Worsened metrics

Number of medium supply chain risk alerts

1

increased byInfinity%

No dependency changes