@flopflip/cache 0.0.0-canary-20240411092321 → 14.0.0

package/dist/declarations/src/cache/cache.d.ts

@@ -0,0 +1,10 @@
+import { type TAdapter, type TAdapterIdentifiers, type TCacheIdentifiers, type TFlags } from '@flopflip/types';
+declare function getCachePrefix(adapterIdentifiers: TAdapterIdentifiers): string;
+declare function getCache(cacheIdentifier: TCacheIdentifiers, adapterIdentifiers: TAdapterIdentifiers, cacheKey?: string): Promise<{
+    set(flags: TFlags): any;
+    get(): any;
+    unset(): any;
+}>;
+declare function getCachedFlags(cacheIdentifier: TCacheIdentifiers, adapterIdentifiers: TAdapterIdentifiers): TFlags;
+declare function getAllCachedFlags(adapter: TAdapter, cacheIdentifier?: TCacheIdentifiers): TFlags;
+export { getAllCachedFlags, getCache, getCachedFlags, getCachePrefix };

package/dist/declarations/src/cache/index.d.ts

@@ -0,0 +1,3 @@
+declare const version = "__@FLOPFLIP/VERSION_OF_RELEASE__";
+export { version };
+export { getAllCachedFlags, getCache, getCachedFlags } from "./cache.js";

package/dist/declarations/src/index.d.ts

@@ -0,0 +1,3 @@
+declare const version = "__@FLOPFLIP/VERSION_OF_RELEASE__";
+export { getAllCachedFlags, getCache, getCachedFlags } from "./cache/index.js";
+export { version };

package/dist/flopflip-cache.cjs.d.ts

@@ -1,2 +1,2 @@
-export * from "../src/index";
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmxvcGZsaXAtY2FjaGUuY2pzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEifQ==
+export * from "./declarations/src/index";
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmxvcGZsaXAtY2FjaGUuY2pzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuL2RlY2xhcmF0aW9ucy9zcmMvaW5kZXguZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSJ9

package/dist/flopflip-cache.cjs.dev.js

@@ -0,0 +1,160 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var types = require('@flopflip/types');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+function toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+
+function toPropertyKey(t) {
+  var i = toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+
+function _defineProperty(obj, key, value) {
+  key = toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function (r) {
+      return Object.getOwnPropertyDescriptor(e, r).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread2(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
+      _defineProperty(e, r, t[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+    });
+  }
+  return e;
+}
+
+const FLAGS_CACHE_KEY = 'flags';
+const FLAGS_REFERENCE_CACHE_KEY = 'flags-reference';
+function getCachePrefix(adapterIdentifiers) {
+  return "@flopflip/".concat(adapterIdentifiers, "-adapter");
+}
+async function importCache(cacheIdentifier) {
+  let cacheModule;
+  switch (cacheIdentifier) {
+    case types.cacheIdentifiers.local:
+      {
+        cacheModule = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@flopflip/localstorage-cache')); });
+        break;
+      }
+    case types.cacheIdentifiers.session:
+      {
+        cacheModule = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@flopflip/sessionstorage-cache')); });
+        break;
+      }
+  }
+  return cacheModule;
+}
+async function getCache(cacheIdentifier, adapterIdentifiers, cacheKey) {
+  const cacheModule = await importCache(cacheIdentifier);
+  const CACHE_PREFIX = getCachePrefix(adapterIdentifiers);
+  const createCache = cacheModule.default;
+  const flagsCachePrefix = [CACHE_PREFIX, cacheKey].filter(Boolean).join('/');
+  const flagsCache = createCache({
+    prefix: flagsCachePrefix
+  });
+  const referenceCache = createCache({
+    prefix: CACHE_PREFIX
+  });
+  return {
+    set(flags) {
+      const haveFlagsBeenWritten = flagsCache.set(FLAGS_CACHE_KEY, flags);
+      if (haveFlagsBeenWritten) {
+        referenceCache.set(FLAGS_REFERENCE_CACHE_KEY, [flagsCachePrefix, FLAGS_CACHE_KEY].join('/'));
+      }
+      return haveFlagsBeenWritten;
+    },
+    get() {
+      return flagsCache.get(FLAGS_CACHE_KEY);
+    },
+    unset() {
+      referenceCache.unset(FLAGS_REFERENCE_CACHE_KEY);
+      return flagsCache.unset(FLAGS_CACHE_KEY);
+    }
+  };
+}
+function getCachedFlags(cacheIdentifier, adapterIdentifiers) {
+  const CACHE_PREFIX = getCachePrefix(adapterIdentifiers);
+  const cacheModule = cacheIdentifier === types.cacheIdentifiers.local ? localStorage : sessionStorage;
+  const flagReferenceKey = [CACHE_PREFIX, FLAGS_REFERENCE_CACHE_KEY].join('/');
+  const referenceToCachedFlags = cacheModule.getItem(flagReferenceKey);
+  if (referenceToCachedFlags) {
+    try {
+      const cacheKey = JSON.parse(referenceToCachedFlags);
+      const cachedFlags = cacheModule.getItem(cacheKey);
+      if (cacheKey && cachedFlags) {
+        return JSON.parse(cachedFlags);
+      }
+    } catch (error) {
+      console.warn("@flopflip/cache: Failed to parse cached flags from ".concat(cacheIdentifier, "."));
+    }
+  }
+  return {};
+}
+function getAllCachedFlags(adapter, cacheIdentifier) {
+  if (!cacheIdentifier) {
+    return {};
+  }
+  if (adapter.effectIds) {
+    return adapter.effectIds.reduce((defaultFlags, effectId) => _objectSpread2(_objectSpread2({}, defaultFlags), getCachedFlags(cacheIdentifier, effectId)), {});
+  }
+  return getCachedFlags(cacheIdentifier, adapter.id);
+}
+
+const version = "14.0.0";
+
+exports.getAllCachedFlags = getAllCachedFlags;
+exports.getCache = getCache;
+exports.getCachedFlags = getCachedFlags;
+exports.version = version;

package/dist/flopflip-cache.cjs.js

@@ -1,16 +1,7 @@
-"use strict";
-// this file might look strange and you might be wondering what it's for
-// it's lets you import your source files by importing this entrypoint
-// as you would import it if it was built with preconstruct build
-// this file is slightly different to some others though
-// it has a require hook which compiles your code with Babel
-// this means that you don't have to set up @babel/register or anything like that
-// but you can still require this module and it'll be compiled
+'use strict';
 
-// this bit of code imports the require hook and registers it
-let unregister = require("../../../node_modules/.pnpm/@preconstruct+hook@0.4.0/node_modules/@preconstruct/hook").___internalHook(typeof __dirname === 'undefined' ? undefined : __dirname, "../../..", "..");
-
-// this re-exports the source file
-module.exports = require("../src/index.ts");
-
-unregister();
+if (process.env.NODE_ENV === "production") {
+  module.exports = require("./flopflip-cache.cjs.prod.js");
+} else {
+  module.exports = require("./flopflip-cache.cjs.dev.js");
+}

package/dist/flopflip-cache.cjs.prod.js

@@ -0,0 +1,160 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var types = require('@flopflip/types');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+function toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+
+function toPropertyKey(t) {
+  var i = toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+
+function _defineProperty(obj, key, value) {
+  key = toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function (r) {
+      return Object.getOwnPropertyDescriptor(e, r).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread2(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
+      _defineProperty(e, r, t[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+    });
+  }
+  return e;
+}
+
+const FLAGS_CACHE_KEY = 'flags';
+const FLAGS_REFERENCE_CACHE_KEY = 'flags-reference';
+function getCachePrefix(adapterIdentifiers) {
+  return "@flopflip/".concat(adapterIdentifiers, "-adapter");
+}
+async function importCache(cacheIdentifier) {
+  let cacheModule;
+  switch (cacheIdentifier) {
+    case types.cacheIdentifiers.local:
+      {
+        cacheModule = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@flopflip/localstorage-cache')); });
+        break;
+      }
+    case types.cacheIdentifiers.session:
+      {
+        cacheModule = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@flopflip/sessionstorage-cache')); });
+        break;
+      }
+  }
+  return cacheModule;
+}
+async function getCache(cacheIdentifier, adapterIdentifiers, cacheKey) {
+  const cacheModule = await importCache(cacheIdentifier);
+  const CACHE_PREFIX = getCachePrefix(adapterIdentifiers);
+  const createCache = cacheModule.default;
+  const flagsCachePrefix = [CACHE_PREFIX, cacheKey].filter(Boolean).join('/');
+  const flagsCache = createCache({
+    prefix: flagsCachePrefix
+  });
+  const referenceCache = createCache({
+    prefix: CACHE_PREFIX
+  });
+  return {
+    set(flags) {
+      const haveFlagsBeenWritten = flagsCache.set(FLAGS_CACHE_KEY, flags);
+      if (haveFlagsBeenWritten) {
+        referenceCache.set(FLAGS_REFERENCE_CACHE_KEY, [flagsCachePrefix, FLAGS_CACHE_KEY].join('/'));
+      }
+      return haveFlagsBeenWritten;
+    },
+    get() {
+      return flagsCache.get(FLAGS_CACHE_KEY);
+    },
+    unset() {
+      referenceCache.unset(FLAGS_REFERENCE_CACHE_KEY);
+      return flagsCache.unset(FLAGS_CACHE_KEY);
+    }
+  };
+}
+function getCachedFlags(cacheIdentifier, adapterIdentifiers) {
+  const CACHE_PREFIX = getCachePrefix(adapterIdentifiers);
+  const cacheModule = cacheIdentifier === types.cacheIdentifiers.local ? localStorage : sessionStorage;
+  const flagReferenceKey = [CACHE_PREFIX, FLAGS_REFERENCE_CACHE_KEY].join('/');
+  const referenceToCachedFlags = cacheModule.getItem(flagReferenceKey);
+  if (referenceToCachedFlags) {
+    try {
+      const cacheKey = JSON.parse(referenceToCachedFlags);
+      const cachedFlags = cacheModule.getItem(cacheKey);
+      if (cacheKey && cachedFlags) {
+        return JSON.parse(cachedFlags);
+      }
+    } catch (error) {
+      console.warn("@flopflip/cache: Failed to parse cached flags from ".concat(cacheIdentifier, "."));
+    }
+  }
+  return {};
+}
+function getAllCachedFlags(adapter, cacheIdentifier) {
+  if (!cacheIdentifier) {
+    return {};
+  }
+  if (adapter.effectIds) {
+    return adapter.effectIds.reduce((defaultFlags, effectId) => _objectSpread2(_objectSpread2({}, defaultFlags), getCachedFlags(cacheIdentifier, effectId)), {});
+  }
+  return getCachedFlags(cacheIdentifier, adapter.id);
+}
+
+const version = "14.0.0";
+
+exports.getAllCachedFlags = getAllCachedFlags;
+exports.getCache = getCache;
+exports.getCachedFlags = getCachedFlags;
+exports.version = version;

package/dist/flopflip-cache.esm.js

@@ -0,0 +1,135 @@
+import { cacheIdentifiers } from '@flopflip/types';
+
+function toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+
+function toPropertyKey(t) {
+  var i = toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+
+function _defineProperty(obj, key, value) {
+  key = toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function (r) {
+      return Object.getOwnPropertyDescriptor(e, r).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread2(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
+      _defineProperty(e, r, t[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+    });
+  }
+  return e;
+}
+
+const FLAGS_CACHE_KEY = 'flags';
+const FLAGS_REFERENCE_CACHE_KEY = 'flags-reference';
+function getCachePrefix(adapterIdentifiers) {
+  return "@flopflip/".concat(adapterIdentifiers, "-adapter");
+}
+async function importCache(cacheIdentifier) {
+  let cacheModule;
+  switch (cacheIdentifier) {
+    case cacheIdentifiers.local:
+      {
+        cacheModule = await import('@flopflip/localstorage-cache');
+        break;
+      }
+    case cacheIdentifiers.session:
+      {
+        cacheModule = await import('@flopflip/sessionstorage-cache');
+        break;
+      }
+  }
+  return cacheModule;
+}
+async function getCache(cacheIdentifier, adapterIdentifiers, cacheKey) {
+  const cacheModule = await importCache(cacheIdentifier);
+  const CACHE_PREFIX = getCachePrefix(adapterIdentifiers);
+  const createCache = cacheModule.default;
+  const flagsCachePrefix = [CACHE_PREFIX, cacheKey].filter(Boolean).join('/');
+  const flagsCache = createCache({
+    prefix: flagsCachePrefix
+  });
+  const referenceCache = createCache({
+    prefix: CACHE_PREFIX
+  });
+  return {
+    set(flags) {
+      const haveFlagsBeenWritten = flagsCache.set(FLAGS_CACHE_KEY, flags);
+      if (haveFlagsBeenWritten) {
+        referenceCache.set(FLAGS_REFERENCE_CACHE_KEY, [flagsCachePrefix, FLAGS_CACHE_KEY].join('/'));
+      }
+      return haveFlagsBeenWritten;
+    },
+    get() {
+      return flagsCache.get(FLAGS_CACHE_KEY);
+    },
+    unset() {
+      referenceCache.unset(FLAGS_REFERENCE_CACHE_KEY);
+      return flagsCache.unset(FLAGS_CACHE_KEY);
+    }
+  };
+}
+function getCachedFlags(cacheIdentifier, adapterIdentifiers) {
+  const CACHE_PREFIX = getCachePrefix(adapterIdentifiers);
+  const cacheModule = cacheIdentifier === cacheIdentifiers.local ? localStorage : sessionStorage;
+  const flagReferenceKey = [CACHE_PREFIX, FLAGS_REFERENCE_CACHE_KEY].join('/');
+  const referenceToCachedFlags = cacheModule.getItem(flagReferenceKey);
+  if (referenceToCachedFlags) {
+    try {
+      const cacheKey = JSON.parse(referenceToCachedFlags);
+      const cachedFlags = cacheModule.getItem(cacheKey);
+      if (cacheKey && cachedFlags) {
+        return JSON.parse(cachedFlags);
+      }
+    } catch (error) {
+      console.warn("@flopflip/cache: Failed to parse cached flags from ".concat(cacheIdentifier, "."));
+    }
+  }
+  return {};
+}
+function getAllCachedFlags(adapter, cacheIdentifier) {
+  if (!cacheIdentifier) {
+    return {};
+  }
+  if (adapter.effectIds) {
+    return adapter.effectIds.reduce((defaultFlags, effectId) => _objectSpread2(_objectSpread2({}, defaultFlags), getCachedFlags(cacheIdentifier, effectId)), {});
+  }
+  return getCachedFlags(cacheIdentifier, adapter.id);
+}
+
+const version = "14.0.0";
+
+export { getAllCachedFlags, getCache, getCachedFlags, version };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flopflip/cache",
-  "version": "0.0.0-canary-20240411092321",
+  "version": "14.0.0",
   "description": "Caching for flipflop adapters",
   "main": "dist/flopflip-cache.cjs.js",
   "module": "dist/flopflip-cache.esm.js",
@@ -29,8 +29,8 @@
     "client"
   ],
   "dependencies": {
-    "@flopflip/localstorage-cache": "0.0.0-canary-20240411092321",
-    "@flopflip/sessionstorage-cache": "0.0.0-canary-20240411092321",
-    "@flopflip/types": "0.0.0-canary-20240411092321"
+    "@flopflip/localstorage-cache": "14.0.0",
+    "@flopflip/sessionstorage-cache": "14.0.0",
+    "@flopflip/types": "14.0.0"
   }
 }