@fairfox/polly 0.29.1 → 0.29.2

package/dist/src/shared/lib/guards.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Type guards for walking `unknown` values safely.
+ *
+ * Polly touches a lot of shapes it doesn't own: parsed JSON bodies
+ * from the signalling server, IndexedDB records, `postMessage`
+ * payloads, storage adapter returns. TypeScript sees every one of
+ * those as `unknown`, and the ergonomic-but-unsafe fix — a bare `as`
+ * cast — hides every shape mismatch until runtime. The helpers below
+ * are the thinnest possible layer that turns a runtime shape check
+ * into a compile-time narrowing, so the code that follows can read
+ * the value without a cast.
+ *
+ * Each guard checks own-properties only (`Object.hasOwn`), not the
+ * prototype chain. Walking into a prototype would make a simple
+ * `hasKeyInObject(x, "toString")` pass for any object, which is
+ * never what a caller looking for a specific data key intends.
+ */
+/** Narrow `input` to an object carrying its own `key`. Returns true
+ * when the input is a non-null object with an own property under
+ * the given key. The value under the key is left as `unknown`;
+ * callers narrow further with `Array.isArray`, `typeof`, or another
+ * guard. */
+export declare function hasKeyInObject<K extends string>(input: unknown, key: K): input is Record<K, unknown>;
+/** Narrow `input` to a plain object (non-null, non-array). Useful as
+ * a prelude to reads off a record whose shape is known at the
+ * call site but typed as `unknown`. */
+export declare function isRecord(input: unknown): input is Record<string, unknown>;

package/dist/src/shared/lib/guards.js

@@ -0,0 +1,84 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/shared/lib/guards.ts
+function hasKeyInObject(input, key) {
+  return typeof input === "object" && input !== null && Object.hasOwn(input, key);
+}
+function isRecord(input) {
+  return typeof input === "object" && input !== null && !Array.isArray(input);
+}
+export {
+  isRecord,
+  hasKeyInObject
+};
+
+//# debugId=36892B8B579A457A64756E2164756E21

package/dist/src/shared/lib/guards.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/shared/lib/guards.ts"],
+  "sourcesContent": [
+    "/**\n * Type guards for walking `unknown` values safely.\n *\n * Polly touches a lot of shapes it doesn't own: parsed JSON bodies\n * from the signalling server, IndexedDB records, `postMessage`\n * payloads, storage adapter returns. TypeScript sees every one of\n * those as `unknown`, and the ergonomic-but-unsafe fix — a bare `as`\n * cast — hides every shape mismatch until runtime. The helpers below\n * are the thinnest possible layer that turns a runtime shape check\n * into a compile-time narrowing, so the code that follows can read\n * the value without a cast.\n *\n * Each guard checks own-properties only (`Object.hasOwn`), not the\n * prototype chain. Walking into a prototype would make a simple\n * `hasKeyInObject(x, \"toString\")` pass for any object, which is\n * never what a caller looking for a specific data key intends.\n */\n\n/** Narrow `input` to an object carrying its own `key`. Returns true\n * when the input is a non-null object with an own property under\n * the given key. The value under the key is left as `unknown`;\n * callers narrow further with `Array.isArray`, `typeof`, or another\n * guard. */\nexport function hasKeyInObject<K extends string>(\n  input: unknown,\n  key: K\n): input is Record<K, unknown> {\n  return typeof input === \"object\" && input !== null && Object.hasOwn(input, key);\n}\n\n/** Narrow `input` to a plain object (non-null, non-array). Useful as\n * a prelude to reads off a record whose shape is known at the\n * call site but typed as `unknown`. */\nexport function isRecord(input: unknown): input is Record<string, unknown> {\n  return typeof input === \"object\" && input !== null && !Array.isArray(input);\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuBO,SAAS,cAAgC,CAC9C,OACA,KAC6B;AAAA,EAC7B,OAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,OAAO,OAAO,OAAO,GAAG;AAAA;AAMzE,SAAS,QAAQ,CAAC,OAAkD;AAAA,EACzE,OAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;AAAA;",
+  "debugId": "36892B8B579A457A64756E2164756E21",
+  "names": []
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fairfox/polly",
-  "version": "0.29.1",
+  "version": "0.29.2",
   "private": false,
   "type": "module",
   "description": "Multi-execution-context framework with reactive state and cross-context messaging for Chrome extensions, PWAs, and worker-based applications",
@@ -46,6 +46,10 @@
       "import": "./dist/src/shared/lib/errors.js",
       "types": "./dist/shared/lib/errors.d.ts"
     },
+    "./guards": {
+      "import": "./dist/src/shared/lib/guards.js",
+      "types": "./dist/src/shared/lib/guards.d.ts"
+    },
     "./types": {
       "import": "./dist/src/shared/types/messages.js",
       "types": "./dist/shared/types/messages.d.ts"