keyv-registry 0.1.0

package/dist/cjs/types.d.cts

@@ -0,0 +1,33 @@
+import type Keyv from 'keyv';
+/**
+ * Configuration for a protocol adapter
+ */
+export interface AdapterConfig {
+    /** npm package name, or null for built-in adapters */
+    package: string | null;
+    /** Named export from the package (default: 'default') */
+    exportName?: string;
+    /** Custom function to map URL to adapter options */
+    optionsMapper?: (url: URL) => Record<string, unknown>;
+}
+/**
+ * Options for createStore
+ */
+export interface CreateStoreOptions {
+    /** Pre-instantiated adapter (bypasses URI loading) */
+    store?: unknown;
+    /** Keyv namespace */
+    namespace?: string;
+    /** Default TTL in milliseconds */
+    ttl?: number;
+    /** Additional Keyv options */
+    [key: string]: unknown;
+}
+/**
+ * Callback type for createStore
+ */
+export type CreateStoreCallback<T> = (err: Error | null, store?: Keyv<T>) => void;
+/**
+ * Internal callback type for loadAdapter
+ */
+export type LoadAdapterCallback = (err: Error | null, Adapter?: unknown) => void;

package/dist/cjs/types.d.ts

@@ -0,0 +1,33 @@
+import type Keyv from 'keyv';
+/**
+ * Configuration for a protocol adapter
+ */
+export interface AdapterConfig {
+    /** npm package name, or null for built-in adapters */
+    package: string | null;
+    /** Named export from the package (default: 'default') */
+    exportName?: string;
+    /** Custom function to map URL to adapter options */
+    optionsMapper?: (url: URL) => Record<string, unknown>;
+}
+/**
+ * Options for createStore
+ */
+export interface CreateStoreOptions {
+    /** Pre-instantiated adapter (bypasses URI loading) */
+    store?: unknown;
+    /** Keyv namespace */
+    namespace?: string;
+    /** Default TTL in milliseconds */
+    ttl?: number;
+    /** Additional Keyv options */
+    [key: string]: unknown;
+}
+/**
+ * Callback type for createStore
+ */
+export type CreateStoreCallback<T> = (err: Error | null, store?: Keyv<T>) => void;
+/**
+ * Internal callback type for loadAdapter
+ */
+export type LoadAdapterCallback = (err: Error | null, Adapter?: unknown) => void;

package/dist/cjs/types.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":""}

package/dist/cjs/utils.d.cts

@@ -0,0 +1,8 @@
+/**
+ * Resolve file path from URL, handling ~ and . prefixes
+ */
+export declare function resolveFilePath(url: URL): string;
+/**
+ * Parse URL search params into options object with type conversion
+ */
+export declare function parseUriOptions(url: URL): Record<string, unknown>;

package/dist/cjs/utils.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Resolve file path from URL, handling ~ and . prefixes
+ */
+export declare function resolveFilePath(url: URL): string;
+/**
+ * Parse URL search params into options object with type conversion
+ */
+export declare function parseUriOptions(url: URL): Record<string, unknown>;

package/dist/cjs/utils.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get parseUriOptions () {
+        return parseUriOptions;
+    },
+    get resolveFilePath () {
+        return resolveFilePath;
+    }
+});
+var _nodefs = /*#__PURE__*/ _interop_require_wildcard(require("node:fs"));
+var _nodeos = /*#__PURE__*/ _interop_require_wildcard(require("node:os"));
+var _nodepath = /*#__PURE__*/ _interop_require_wildcard(require("node:path"));
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function resolveFilePath(url) {
+    var filePath = url.pathname;
+    // Handle ~ for home directory
+    if (url.host === '~') {
+        filePath = _nodepath.join(_nodeos.homedir(), filePath.slice(1));
+    } else if (url.host === '.') {
+        filePath = _nodepath.join(process.cwd(), filePath.slice(1));
+    }
+    // Ensure directory exists
+    _nodefs.mkdirSync(_nodepath.dirname(filePath), {
+        recursive: true
+    });
+    return filePath;
+}
+function parseUriOptions(url) {
+    var options = {};
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = url.searchParams[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _step_value = _sliced_to_array(_step.value, 2), key = _step_value[0], value = _step_value[1];
+            // Auto-convert types
+            if (value === 'true') options[key] = true;
+            else if (value === 'false') options[key] = false;
+            else if (/^\d+$/.test(value)) options[key] = Number.parseInt(value, 10);
+            else if (/^\d+\.\d+$/.test(value)) options[key] = Number.parseFloat(value);
+            else options[key] = value;
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return options;
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/keyv/keyv-registry/src/utils.ts"],"sourcesContent":["import * as fs from 'node:fs';\nimport * as os from 'node:os';\nimport * as path from 'node:path';\n\n/**\n * Resolve file path from URL, handling ~ and . prefixes\n */\nexport function resolveFilePath(url: URL): string {\n  let filePath = url.pathname;\n\n  // Handle ~ for home directory\n  if (url.host === '~') {\n    filePath = path.join(os.homedir(), filePath.slice(1));\n  }\n  // Handle . for current directory\n  else if (url.host === '.') {\n    filePath = path.join(process.cwd(), filePath.slice(1));\n  }\n\n  // Ensure directory exists\n  fs.mkdirSync(path.dirname(filePath), { recursive: true });\n\n  return filePath;\n}\n\n/**\n * Parse URL search params into options object with type conversion\n */\nexport function parseUriOptions(url: URL): Record<string, unknown> {\n  const options: Record<string, unknown> = {};\n\n  for (const [key, value] of url.searchParams) {\n    // Auto-convert types\n    if (value === 'true') options[key] = true;\n    else if (value === 'false') options[key] = false;\n    else if (/^\\d+$/.test(value)) options[key] = Number.parseInt(value, 10);\n    else if (/^\\d+\\.\\d+$/.test(value)) options[key] = Number.parseFloat(value);\n    else options[key] = value;\n  }\n\n  return options;\n}\n"],"names":["parseUriOptions","resolveFilePath","url","filePath","pathname","host","path","join","os","homedir","slice","process","cwd","fs","mkdirSync","dirname","recursive","options","searchParams","key","value","test","Number","parseInt","parseFloat"],"mappings":";;;;;;;;;;;QA4BgBA;eAAAA;;QArBAC;eAAAA;;;8DAPI;8DACA;gEACE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKf,SAASA,gBAAgBC,GAAQ;IACtC,IAAIC,WAAWD,IAAIE,QAAQ;IAE3B,8BAA8B;IAC9B,IAAIF,IAAIG,IAAI,KAAK,KAAK;QACpBF,WAAWG,UAAKC,IAAI,CAACC,QAAGC,OAAO,IAAIN,SAASO,KAAK,CAAC;IACpD,OAEK,IAAIR,IAAIG,IAAI,KAAK,KAAK;QACzBF,WAAWG,UAAKC,IAAI,CAACI,QAAQC,GAAG,IAAIT,SAASO,KAAK,CAAC;IACrD;IAEA,0BAA0B;IAC1BG,QAAGC,SAAS,CAACR,UAAKS,OAAO,CAACZ,WAAW;QAAEa,WAAW;IAAK;IAEvD,OAAOb;AACT;AAKO,SAASH,gBAAgBE,GAAQ;IACtC,IAAMe,UAAmC,CAAC;QAErC,kCAAA,2BAAA;;QAAL,QAAK,YAAsBf,IAAIgB,YAAY,qBAAtC,SAAA,6BAAA,QAAA,yBAAA,iCAAwC;YAAxC,mCAAA,iBAAOC,sBAAKC;YACf,qBAAqB;YACrB,IAAIA,UAAU,QAAQH,OAAO,CAACE,IAAI,GAAG;iBAChC,IAAIC,UAAU,SAASH,OAAO,CAACE,IAAI,GAAG;iBACtC,IAAI,QAAQE,IAAI,CAACD,QAAQH,OAAO,CAACE,IAAI,GAAGG,OAAOC,QAAQ,CAACH,OAAO;iBAC/D,IAAI,aAAaC,IAAI,CAACD,QAAQH,OAAO,CAACE,IAAI,GAAGG,OAAOE,UAAU,CAACJ;iBAC/DH,OAAO,CAACE,IAAI,GAAGC;QACtB;;QAPK;QAAA;;;iBAAA,6BAAA;gBAAA;;;gBAAA;sBAAA;;;;IASL,OAAOH;AACT"}

package/dist/cjs/worker.d.cts

@@ -0,0 +1,5 @@
+import type { CreateStoreCallback, CreateStoreOptions } from './types.js';
+/**
+ * Core worker function that creates a Keyv store
+ */
+export default function worker<T>(uri: string, options: CreateStoreOptions, callback: CreateStoreCallback<T>): void;

package/dist/cjs/worker.d.ts

@@ -0,0 +1,5 @@
+import type { CreateStoreCallback, CreateStoreOptions } from './types.js';
+/**
+ * Core worker function that creates a Keyv store
+ */
+export default function worker<T>(uri: string, options: CreateStoreOptions, callback: CreateStoreCallback<T>): void;

package/dist/cjs/worker.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, /**
+ * Core worker function that creates a Keyv store
+ */ "default", {
+    enumerable: true,
+    get: function() {
+        return worker;
+    }
+});
+var _keyv = /*#__PURE__*/ _interop_require_default(require("keyv"));
+var _loadAdapterts = /*#__PURE__*/ _interop_require_default(require("./loadAdapter.js"));
+var _registryts = require("./registry.js");
+var _utilsts = require("./utils.js");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function _object_without_properties(source, excluded) {
+    if (source == null) return {};
+    var target = _object_without_properties_loose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceSymbolKeys.length; i++){
+            key = sourceSymbolKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _object_without_properties_loose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+function worker(uri, options, callback) {
+    // Passthrough: pre-instantiated adapter provided
+    if (options.store) {
+        try {
+            var keyv = new _keyv.default(_object_spread({}, options));
+            callback(null, keyv);
+        } catch (err) {
+            callback(err);
+        }
+        return;
+    }
+    // Parse URI
+    var url;
+    try {
+        url = new URL(uri);
+    } catch (_err) {
+        callback(new Error("Invalid URI: ".concat(uri)));
+        return;
+    }
+    var config = (0, _registryts.getAdapterConfig)(url.protocol);
+    if (!config) {
+        callback(new Error("Unknown protocol: ".concat(url.protocol, ". Use registerAdapter() to add support.")));
+        return;
+    }
+    // Memory store - no package needed
+    if (config.package === null) {
+        try {
+            var keyv1 = new _keyv.default(_object_spread({}, (0, _utilsts.parseUriOptions)(url), options));
+            callback(null, keyv1);
+        } catch (err) {
+            callback(err);
+        }
+        return;
+    }
+    // Load adapter (install if needed)
+    (0, _loadAdapterts.default)(config.package, config.exportName, function(err, AdapterClass) {
+        if (err) {
+            callback(err);
+            return;
+        }
+        try {
+            var _config_optionsMapper;
+            var _config_optionsMapper1;
+            // Build adapter options: URI params + custom mapper + user options
+            var adapterOptions = _object_spread({}, (0, _utilsts.parseUriOptions)(url), (_config_optionsMapper1 = (_config_optionsMapper = config.optionsMapper) === null || _config_optionsMapper === void 0 ? void 0 : _config_optionsMapper.call(config, url)) !== null && _config_optionsMapper1 !== void 0 ? _config_optionsMapper1 : {
+                uri: uri
+            }, options);
+            // Remove store from adapter options to avoid confusion
+            var _ = adapterOptions.store, cleanAdapterOptions = _object_without_properties(adapterOptions, [
+                "store"
+            ]);
+            var storeInstance = new AdapterClass(cleanAdapterOptions);
+            var keyv = new _keyv.default(_object_spread({
+                store: storeInstance
+            }, options));
+            callback(null, keyv);
+        } catch (createErr) {
+            callback(createErr);
+        }
+    });
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/worker.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/keyv/keyv-registry/src/worker.ts"],"sourcesContent":["import Keyv from 'keyv';\nimport loadAdapter from './loadAdapter.ts';\nimport { getAdapterConfig } from './registry.ts';\nimport type { CreateStoreCallback, CreateStoreOptions } from './types.ts';\nimport { parseUriOptions } from './utils.ts';\n\n/**\n * Core worker function that creates a Keyv store\n */\nexport default function worker<T>(uri: string, options: CreateStoreOptions, callback: CreateStoreCallback<T>): void {\n  // Passthrough: pre-instantiated adapter provided\n  if (options.store) {\n    try {\n      const keyv = new Keyv<T>({ ...options });\n      callback(null, keyv);\n    } catch (err) {\n      callback(err as Error);\n    }\n    return;\n  }\n\n  // Parse URI\n  let url: URL;\n  try {\n    url = new URL(uri);\n  } catch (_err) {\n    callback(new Error(`Invalid URI: ${uri}`));\n    return;\n  }\n\n  const config = getAdapterConfig(url.protocol);\n\n  if (!config) {\n    callback(new Error(`Unknown protocol: ${url.protocol}. Use registerAdapter() to add support.`));\n    return;\n  }\n\n  // Memory store - no package needed\n  if (config.package === null) {\n    try {\n      const keyv = new Keyv<T>({ ...parseUriOptions(url), ...options });\n      callback(null, keyv);\n    } catch (err) {\n      callback(err as Error);\n    }\n    return;\n  }\n\n  // Load adapter (install if needed)\n  loadAdapter(config.package, config.exportName, (err, AdapterClass) => {\n    if (err) {\n      callback(err);\n      return;\n    }\n\n    try {\n      // Build adapter options: URI params + custom mapper + user options\n      const adapterOptions = {\n        ...parseUriOptions(url),\n        ...(config.optionsMapper?.(url) ?? { uri }),\n        ...options,\n      };\n\n      // Remove store from adapter options to avoid confusion\n      const { store: _, ...cleanAdapterOptions } = adapterOptions;\n\n      const storeInstance = new (AdapterClass as new (options: Record<string, unknown>) => unknown)(cleanAdapterOptions);\n      const keyv = new Keyv<T>({ store: storeInstance, ...options });\n\n      callback(null, keyv);\n    } catch (createErr) {\n      callback(createErr as Error);\n    }\n  });\n}\n"],"names":["worker","uri","options","callback","store","keyv","Keyv","err","url","URL","_err","Error","config","getAdapterConfig","protocol","package","parseUriOptions","loadAdapter","exportName","AdapterClass","adapterOptions","optionsMapper","_","cleanAdapterOptions","storeInstance","createErr"],"mappings":";;;;+BAMA;;CAEC,GACD;;;eAAwBA;;;2DATP;oEACO;0BACS;uBAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKjB,SAASA,OAAUC,GAAW,EAAEC,OAA2B,EAAEC,QAAgC;IAC1G,iDAAiD;IACjD,IAAID,QAAQE,KAAK,EAAE;QACjB,IAAI;YACF,IAAMC,OAAO,IAAIC,aAAI,CAAI,mBAAKJ;YAC9BC,SAAS,MAAME;QACjB,EAAE,OAAOE,KAAK;YACZJ,SAASI;QACX;QACA;IACF;IAEA,YAAY;IACZ,IAAIC;IACJ,IAAI;QACFA,MAAM,IAAIC,IAAIR;IAChB,EAAE,OAAOS,MAAM;QACbP,SAAS,IAAIQ,MAAM,AAAC,gBAAmB,OAAJV;QACnC;IACF;IAEA,IAAMW,SAASC,IAAAA,4BAAgB,EAACL,IAAIM,QAAQ;IAE5C,IAAI,CAACF,QAAQ;QACXT,SAAS,IAAIQ,MAAM,AAAC,qBAAiC,OAAbH,IAAIM,QAAQ,EAAC;QACrD;IACF;IAEA,mCAAmC;IACnC,IAAIF,OAAOG,OAAO,KAAK,MAAM;QAC3B,IAAI;YACF,IAAMV,QAAO,IAAIC,aAAI,CAAI,mBAAKU,IAAAA,wBAAe,EAACR,MAASN;YACvDC,SAAS,MAAME;QACjB,EAAE,OAAOE,KAAK;YACZJ,SAASI;QACX;QACA;IACF;IAEA,mCAAmC;IACnCU,IAAAA,sBAAW,EAACL,OAAOG,OAAO,EAAEH,OAAOM,UAAU,EAAE,SAACX,KAAKY;QACnD,IAAIZ,KAAK;YACPJ,SAASI;YACT;QACF;QAEA,IAAI;gBAIIK;gBAAAA;YAHN,mEAAmE;YACnE,IAAMQ,iBAAiB,mBAClBJ,IAAAA,wBAAe,EAACR,MACfI,CAAAA,0BAAAA,wBAAAA,OAAOS,aAAa,cAApBT,4CAAAA,2BAAAA,QAAuBJ,kBAAvBI,oCAAAA,yBAA+B;gBAAEX,KAAAA;YAAI,GACtCC;YAGL,uDAAuD;YACvD,IAAQE,AAAOkB,IAA8BF,eAArChB,OAAamB,iDAAwBH;gBAArChB;;YAER,IAAMoB,gBAAgB,IAAKL,aAAmEI;YAC9F,IAAMlB,OAAO,IAAIC,aAAI,CAAI;gBAAEF,OAAOoB;eAAkBtB;YAEpDC,SAAS,MAAME;QACjB,EAAE,OAAOoB,WAAW;YAClBtB,SAASsB;QACX;IACF;AACF"}

package/dist/esm/index.d.ts

@@ -0,0 +1,37 @@
+import type Keyv from 'keyv';
+import type { CreateStoreCallback, CreateStoreOptions } from './types.js';
+export { clearAdapterCache } from './loadAdapter.js';
+export { getRegistry, registerAdapter } from './registry.js';
+export type { AdapterConfig, CreateStoreCallback, CreateStoreOptions } from './types.js';
+/**
+ * Create a Keyv store from a URI string
+ *
+ * Supports dual-boot API (callback or Promise):
+ *
+ * @example
+ * // Promise API
+ * const store = await createStore('redis://localhost:6379');
+ * const file = await createStore('file://~/.cache/app/data.json');
+ * const memory = await createStore('memory://');
+ *
+ * @example
+ * // Callback API
+ * createStore('redis://localhost:6379', (err, store) => {
+ *   if (err) throw err;
+ *   // use store
+ * });
+ *
+ * @example
+ * // With options
+ * const store = await createStore('redis://localhost:6379', {
+ *   namespace: 'myapp',
+ *   ttl: 60000
+ * });
+ *
+ * @example
+ * // Pre-instantiated adapter passthrough
+ * import KeyvRedis from '@keyv/redis';
+ * const redis = new KeyvRedis('redis://localhost:6379');
+ * const store = await createStore('redis://ignored', { store: redis });
+ */
+export default function createStore<T>(uri: string, options?: CreateStoreOptions | CreateStoreCallback<T>, callback?: CreateStoreCallback<T>): undefined | Promise<Keyv<T>>;

package/dist/esm/index.js

@@ -0,0 +1,50 @@
+import worker from './worker.js';
+export { clearAdapterCache } from './loadAdapter.js';
+export { getRegistry, registerAdapter } from './registry.js';
+/**
+ * Create a Keyv store from a URI string
+ *
+ * Supports dual-boot API (callback or Promise):
+ *
+ * @example
+ * // Promise API
+ * const store = await createStore('redis://localhost:6379');
+ * const file = await createStore('file://~/.cache/app/data.json');
+ * const memory = await createStore('memory://');
+ *
+ * @example
+ * // Callback API
+ * createStore('redis://localhost:6379', (err, store) => {
+ *   if (err) throw err;
+ *   // use store
+ * });
+ *
+ * @example
+ * // With options
+ * const store = await createStore('redis://localhost:6379', {
+ *   namespace: 'myapp',
+ *   ttl: 60000
+ * });
+ *
+ * @example
+ * // Pre-instantiated adapter passthrough
+ * import KeyvRedis from '@keyv/redis';
+ * const redis = new KeyvRedis('redis://localhost:6379');
+ * const store = await createStore('redis://ignored', { store: redis });
+ */ export default function createStore(uri, options, callback) {
+    // Normalize arguments
+    if (typeof options === 'function') {
+        callback = options;
+        options = {};
+    }
+    options = options || {};
+    // Callback mode
+    if (typeof callback === 'function') {
+        worker(uri, options, callback);
+        return undefined;
+    }
+    // Promise mode
+    return new Promise((resolve, reject)=>{
+        worker(uri, options, (err, store)=>err ? reject(err) : resolve(store));
+    });
+}

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/keyv/keyv-registry/src/index.ts"],"sourcesContent":["import type Keyv from 'keyv';\nimport type { CreateStoreCallback, CreateStoreOptions } from './types.ts';\nimport worker from './worker.ts';\n\nexport { clearAdapterCache } from './loadAdapter.ts';\nexport { getRegistry, registerAdapter } from './registry.ts';\nexport type { AdapterConfig, CreateStoreCallback, CreateStoreOptions } from './types.ts';\n\n/**\n * Create a Keyv store from a URI string\n *\n * Supports dual-boot API (callback or Promise):\n *\n * @example\n * // Promise API\n * const store = await createStore('redis://localhost:6379');\n * const file = await createStore('file://~/.cache/app/data.json');\n * const memory = await createStore('memory://');\n *\n * @example\n * // Callback API\n * createStore('redis://localhost:6379', (err, store) => {\n *   if (err) throw err;\n *   // use store\n * });\n *\n * @example\n * // With options\n * const store = await createStore('redis://localhost:6379', {\n *   namespace: 'myapp',\n *   ttl: 60000\n * });\n *\n * @example\n * // Pre-instantiated adapter passthrough\n * import KeyvRedis from '@keyv/redis';\n * const redis = new KeyvRedis('redis://localhost:6379');\n * const store = await createStore('redis://ignored', { store: redis });\n */\nexport default function createStore<T>(uri: string, options?: CreateStoreOptions | CreateStoreCallback<T>, callback?: CreateStoreCallback<T>): undefined | Promise<Keyv<T>> {\n  // Normalize arguments\n  if (typeof options === 'function') {\n    callback = options;\n    options = {};\n  }\n  options = options || {};\n\n  // Callback mode\n  if (typeof callback === 'function') {\n    worker(uri, options, callback);\n    return undefined;\n  }\n\n  // Promise mode\n  return new Promise((resolve, reject) => {\n    worker(uri, options as CreateStoreOptions, (err, store) => (err ? reject(err) : resolve(store as Keyv<T>)));\n  });\n}\n"],"names":["worker","clearAdapterCache","getRegistry","registerAdapter","createStore","uri","options","callback","undefined","Promise","resolve","reject","err","store"],"mappings":"AAEA,OAAOA,YAAY,cAAc;AAEjC,SAASC,iBAAiB,QAAQ,mBAAmB;AACrD,SAASC,WAAW,EAAEC,eAAe,QAAQ,gBAAgB;AAG7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BC,GACD,eAAe,SAASC,YAAeC,GAAW,EAAEC,OAAqD,EAAEC,QAAiC;IAC1I,sBAAsB;IACtB,IAAI,OAAOD,YAAY,YAAY;QACjCC,WAAWD;QACXA,UAAU,CAAC;IACb;IACAA,UAAUA,WAAW,CAAC;IAEtB,gBAAgB;IAChB,IAAI,OAAOC,aAAa,YAAY;QAClCP,OAAOK,KAAKC,SAASC;QACrB,OAAOC;IACT;IAEA,eAAe;IACf,OAAO,IAAIC,QAAQ,CAACC,SAASC;QAC3BX,OAAOK,KAAKC,SAA+B,CAACM,KAAKC,QAAWD,MAAMD,OAAOC,OAAOF,QAAQG;IAC1F;AACF"}

package/dist/esm/loadAdapter.d.ts

@@ -0,0 +1,9 @@
+import type { LoadAdapterCallback } from './types.js';
+/**
+ * Load an adapter, installing it dynamically if needed
+ */
+export default function loadAdapter(packageName: string, exportName: string | undefined, callback: LoadAdapterCallback): void;
+/**
+ * Clear the adapter cache (useful for testing)
+ */
+export declare function clearAdapterCache(): void;

package/dist/esm/loadAdapter.js

@@ -0,0 +1,52 @@
+import Module from 'node:module';
+import path from 'node:path';
+import url from 'node:url';
+import installModule from 'install-module-linked';
+// Create require function for ESM compatibility
+const _require = typeof require === 'undefined' ? Module.createRequire(import.meta.url) : require;
+// Determine node_modules path
+const _dirname = path.dirname(typeof __dirname !== 'undefined' ? __dirname : url.fileURLToPath(import.meta.url));
+const nodeModulesPath = path.join(_dirname, '..', '..', 'node_modules');
+// Cache loaded adapters
+const adapterCache = new Map();
+/**
+ * Load an adapter, installing it dynamically if needed
+ */ export default function loadAdapter(packageName, exportName, callback) {
+    const cacheKey = `${packageName}:${exportName !== null && exportName !== void 0 ? exportName : 'default'}`;
+    // Return cached adapter if available
+    if (adapterCache.has(cacheKey)) {
+        callback(null, adapterCache.get(cacheKey));
+        return;
+    }
+    // Try to require first (may already be installed)
+    try {
+        const mod = _require(packageName);
+        var _mod_default;
+        const Adapter = exportName ? mod[exportName] : (_mod_default = mod.default) !== null && _mod_default !== void 0 ? _mod_default : mod;
+        adapterCache.set(cacheKey, Adapter);
+        callback(null, Adapter);
+        return;
+    } catch  {
+        // Not installed - dynamically install then load
+        installModule(packageName, nodeModulesPath, {}, (err)=>{
+            if (err) {
+                callback(err);
+                return;
+            }
+            try {
+                const mod = _require(packageName);
+                var _mod_default;
+                const Adapter = exportName ? mod[exportName] : (_mod_default = mod.default) !== null && _mod_default !== void 0 ? _mod_default : mod;
+                adapterCache.set(cacheKey, Adapter);
+                callback(null, Adapter);
+            } catch (loadErr) {
+                callback(loadErr);
+            }
+        });
+    }
+}
+/**
+ * Clear the adapter cache (useful for testing)
+ */ export function clearAdapterCache() {
+    adapterCache.clear();
+}

package/dist/esm/loadAdapter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/keyv/keyv-registry/src/loadAdapter.ts"],"sourcesContent":["import Module from 'node:module';\nimport path from 'node:path';\nimport url from 'node:url';\nimport installModule from 'install-module-linked';\nimport type { LoadAdapterCallback } from './types.ts';\n\n// Create require function for ESM compatibility\nconst _require = typeof require === 'undefined' ? Module.createRequire(import.meta.url) : require;\n\n// Determine node_modules path\nconst _dirname = path.dirname(typeof __dirname !== 'undefined' ? __dirname : url.fileURLToPath(import.meta.url));\nconst nodeModulesPath = path.join(_dirname, '..', '..', 'node_modules');\n\n// Cache loaded adapters\nconst adapterCache = new Map<string, unknown>();\n\n/**\n * Load an adapter, installing it dynamically if needed\n */\nexport default function loadAdapter(packageName: string, exportName: string | undefined, callback: LoadAdapterCallback): void {\n  const cacheKey = `${packageName}:${exportName ?? 'default'}`;\n\n  // Return cached adapter if available\n  if (adapterCache.has(cacheKey)) {\n    callback(null, adapterCache.get(cacheKey));\n    return;\n  }\n\n  // Try to require first (may already be installed)\n  try {\n    const mod = _require(packageName);\n    const Adapter = exportName ? mod[exportName] : (mod.default ?? mod);\n    adapterCache.set(cacheKey, Adapter);\n    callback(null, Adapter);\n    return;\n  } catch {\n    // Not installed - dynamically install then load\n    installModule(packageName, nodeModulesPath, {}, (err: Error | null) => {\n      if (err) {\n        callback(err);\n        return;\n      }\n      try {\n        const mod = _require(packageName);\n        const Adapter = exportName ? mod[exportName] : (mod.default ?? mod);\n        adapterCache.set(cacheKey, Adapter);\n        callback(null, Adapter);\n      } catch (loadErr) {\n        callback(loadErr as Error);\n      }\n    });\n  }\n}\n\n/**\n * Clear the adapter cache (useful for testing)\n */\nexport function clearAdapterCache(): void {\n  adapterCache.clear();\n}\n"],"names":["Module","path","url","installModule","_require","require","createRequire","_dirname","dirname","__dirname","fileURLToPath","nodeModulesPath","join","adapterCache","Map","loadAdapter","packageName","exportName","callback","cacheKey","has","get","mod","Adapter","default","set","err","loadErr","clearAdapterCache","clear"],"mappings":"AAAA,OAAOA,YAAY,cAAc;AACjC,OAAOC,UAAU,YAAY;AAC7B,OAAOC,SAAS,WAAW;AAC3B,OAAOC,mBAAmB,wBAAwB;AAGlD,gDAAgD;AAChD,MAAMC,WAAW,OAAOC,YAAY,cAAcL,OAAOM,aAAa,CAAC,YAAYJ,GAAG,IAAIG;AAE1F,8BAA8B;AAC9B,MAAME,WAAWN,KAAKO,OAAO,CAAC,OAAOC,cAAc,cAAcA,YAAYP,IAAIQ,aAAa,CAAC,YAAYR,GAAG;AAC9G,MAAMS,kBAAkBV,KAAKW,IAAI,CAACL,UAAU,MAAM,MAAM;AAExD,wBAAwB;AACxB,MAAMM,eAAe,IAAIC;AAEzB;;CAEC,GACD,eAAe,SAASC,YAAYC,WAAmB,EAAEC,UAA8B,EAAEC,QAA6B;IACpH,MAAMC,WAAW,GAAGH,YAAY,CAAC,EAAEC,uBAAAA,wBAAAA,aAAc,WAAW;IAE5D,qCAAqC;IACrC,IAAIJ,aAAaO,GAAG,CAACD,WAAW;QAC9BD,SAAS,MAAML,aAAaQ,GAAG,CAACF;QAChC;IACF;IAEA,kDAAkD;IAClD,IAAI;QACF,MAAMG,MAAMlB,SAASY;YAC2BM;QAAhD,MAAMC,UAAUN,aAAaK,GAAG,CAACL,WAAW,GAAIK,CAAAA,eAAAA,IAAIE,OAAO,cAAXF,0BAAAA,eAAeA;QAC/DT,aAAaY,GAAG,CAACN,UAAUI;QAC3BL,SAAS,MAAMK;QACf;IACF,EAAE,OAAM;QACN,gDAAgD;QAChDpB,cAAca,aAAaL,iBAAiB,CAAC,GAAG,CAACe;YAC/C,IAAIA,KAAK;gBACPR,SAASQ;gBACT;YACF;YACA,IAAI;gBACF,MAAMJ,MAAMlB,SAASY;oBAC2BM;gBAAhD,MAAMC,UAAUN,aAAaK,GAAG,CAACL,WAAW,GAAIK,CAAAA,eAAAA,IAAIE,OAAO,cAAXF,0BAAAA,eAAeA;gBAC/DT,aAAaY,GAAG,CAACN,UAAUI;gBAC3BL,SAAS,MAAMK;YACjB,EAAE,OAAOI,SAAS;gBAChBT,SAASS;YACX;QACF;IACF;AACF;AAEA;;CAEC,GACD,OAAO,SAASC;IACdf,aAAagB,KAAK;AACpB"}

package/dist/esm/package.json

@@ -0,0 +1 @@
+{ "type": "module" }

package/dist/esm/registry.d.ts

@@ -0,0 +1,13 @@
+import type { AdapterConfig } from './types.js';
+/**
+ * Register or override a protocol adapter
+ */
+export declare function registerAdapter(protocol: string, config: AdapterConfig): void;
+/**
+ * Get the current registry (read-only copy)
+ */
+export declare function getRegistry(): Readonly<Record<string, AdapterConfig>>;
+/**
+ * Get adapter config for a protocol
+ */
+export declare function getAdapterConfig(protocol: string): AdapterConfig | undefined;