@fairfox/polly 0.12.3 → 0.13.0

package/dist/src/index.js

@@ -48,6 +48,90 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
+// src/shared/lib/constraints.ts
+var exports_constraints = {};
+__export(exports_constraints, {
+  registerConstraints: () => registerConstraints,
+  registerConstraint: () => registerConstraint,
+  isRuntimeConstraintsEnabled: () => isRuntimeConstraintsEnabled,
+  getRegisteredConstraints: () => getRegisteredConstraints,
+  clearConstraints: () => clearConstraints,
+  checkPreconditions: () => checkPreconditions,
+  checkPostconditions: () => checkPostconditions
+});
+function registerConstraint(field, messageType, constraint) {
+  if (!registry.has(field)) {
+    registry.set(field, new Map);
+  }
+  registry.get(field)?.set(messageType, constraint);
+}
+function registerConstraints(field, constraints) {
+  for (const [messageType, constraint] of Object.entries(constraints)) {
+    const runtimeConstraint = {
+      message: constraint.message
+    };
+    if (typeof constraint.requires === "function") {
+      runtimeConstraint.requires = constraint.requires;
+    }
+    if (typeof constraint.ensures === "function") {
+      runtimeConstraint.ensures = constraint.ensures;
+    }
+    if (runtimeConstraint.requires || runtimeConstraint.ensures) {
+      registerConstraint(field, messageType, runtimeConstraint);
+    }
+  }
+}
+function executeConstraint(predicate, state, messageType, field, customMessage, constraintType = "Precondition") {
+  try {
+    const result = predicate(state);
+    if (!result) {
+      const message = customMessage || `${constraintType} failed for ${messageType} on field ${field}`;
+      throw new Error(message);
+    }
+  } catch (error) {
+    if (error instanceof Error && error.message.includes(`${constraintType} failed`)) {
+      throw error;
+    }
+    const message = customMessage || `${constraintType} check error for ${messageType} on field ${field}`;
+    throw new Error(`${message}: ${error}`);
+  }
+}
+function checkPreconditions(messageType, state) {
+  for (const [field, constraints] of registry) {
+    const constraint = constraints.get(messageType);
+    if (constraint?.requires) {
+      executeConstraint(constraint.requires, state, messageType, field, constraint.message, "Precondition");
+    }
+  }
+}
+function checkPostconditions(messageType, state) {
+  for (const [field, constraints] of registry) {
+    const constraint = constraints.get(messageType);
+    if (constraint?.ensures) {
+      executeConstraint(constraint.ensures, state, messageType, field, constraint.message, "Postcondition");
+    }
+  }
+}
+function clearConstraints() {
+  registry.clear();
+}
+function getRegisteredConstraints() {
+  return new Map(registry);
+}
+function isRuntimeConstraintsEnabled() {
+  if (typeof process !== "undefined" && process.env) {
+    return process.env["POLLY_RUNTIME_CONSTRAINTS"] === "true";
+  }
+  if (typeof Bun !== "undefined" && Bun.env) {
+    return Bun.env["POLLY_RUNTIME_CONSTRAINTS"] === "true";
+  }
+  return false;
+}
+var registry;
+var init_constraints = __esm(() => {
+  registry = new Map;
+});
+
 // src/shared/adapters/chrome/context-menus.chrome.ts
 class ChromeContextMenusAdapter {
   async create(createProperties) {
@@ -724,6 +808,7 @@ class MessageBus {
   port = null;
   errorHandler;
   userErrorHandlers = [];
+  stateAccessor = null;
   messageListener = null;
   constructor(context, adapters, options) {
     this.context = context;
@@ -811,6 +896,9 @@ class MessageBus {
   onError(handler) {
     this.userErrorHandlers.push(handler);
   }
+  setStateAccessor(accessor) {
+    this.stateAccessor = accessor;
+  }
   async sendToBackground(payload, options) {
     return this.send(payload, { ...options, target: "background" });
   }
@@ -968,11 +1056,40 @@ class MessageBus {
     }
     try {
       globalExecutionTracker.track(message.id, message.payload.type);
+      if (this.stateAccessor) {
+        try {
+          const { checkPreconditions: checkPreconditions2, isRuntimeConstraintsEnabled: isRuntimeConstraintsEnabled2 } = await Promise.resolve().then(() => (init_constraints(), exports_constraints));
+          if (isRuntimeConstraintsEnabled2()) {
+            const currentState = this.stateAccessor();
+            checkPreconditions2(message.payload.type, currentState);
+          }
+        } catch (error) {
+          if (error instanceof Error) {
+            throw error;
+          }
+          if (error && typeof error === "object" && "code" in error && error.code === "MODULE_NOT_FOUND") {} else {
+            throw error;
+          }
+        }
+      }
       const handler = handlers[0];
       if (!handler) {
         throw new Error(`Handler not found for ${message.payload.type}`);
       }
       const data = await handler(message.payload, message);
+      if (this.stateAccessor) {
+        try {
+          const { checkPostconditions: checkPostconditions2, isRuntimeConstraintsEnabled: isRuntimeConstraintsEnabled2 } = await Promise.resolve().then(() => (init_constraints(), exports_constraints));
+          if (isRuntimeConstraintsEnabled2()) {
+            const currentState = this.stateAccessor();
+            checkPostconditions2(message.payload.type, currentState);
+          }
+        } catch (error) {
+          if (error instanceof Error && error.message.includes("Postcondition")) {
+            console.error(`[${this.context}] Postcondition failed:`, error.message);
+          }
+        }
+      }
       const response = {
         id: message.id,
         success: true,
@@ -1170,11 +1287,16 @@ function getCurrentContext() {
   return "background";
 }
 function $sharedState(key, initialValue, options = {}) {
-  return createState(key, initialValue, {
+  const sig = createState(key, initialValue, {
     ...options,
     sync: true,
     persist: true
   });
+  const entry = stateRegistry.get(key);
+  if (entry) {
+    sig.loaded = entry.loaded;
+  }
+  return sig;
 }
 function $syncedState(key, initialValue, options = {}) {
   return createState(key, initialValue, {
@@ -1184,11 +1306,16 @@ function $syncedState(key, initialValue, options = {}) {
   });
 }
 function $persistedState(key, initialValue, options = {}) {
-  return createState(key, initialValue, {
+  const sig = createState(key, initialValue, {
     ...options,
     sync: false,
     persist: true
   });
+  const entry = stateRegistry.get(key);
+  if (entry) {
+    sig.loaded = entry.loaded;
+  }
+  return sig;
 }
 function $state(initialValue) {
   return signal(initialValue);
@@ -1224,6 +1351,10 @@ Page scripts are execution contexts for content scripts and should not maintain
 Use state in the content script instead, or use $state() for local-only state.`);
   }
   const sig = signal(initialValue);
+  if (options.verify) {
+    const mirror = JSON.parse(JSON.stringify(initialValue));
+    sig.verify = mirror;
+  }
   const entry = {
     signal: sig,
     clock: 0,
@@ -1256,6 +1387,12 @@ Use state in the content script instead, or use $state() for local-only state.`)
         return;
       }
       previousValue = value;
+      if (options.verify) {
+        const verifySignal = sig;
+        if (verifySignal.verify) {
+          Object.assign(verifySignal.verify, JSON.parse(JSON.stringify(value)));
+        }
+      }
       entry.clock++;
       const doUpdate = () => {
         if (options.persist) {
@@ -1504,14 +1641,77 @@ var uiState = signal2({
   sidebarOpen: false,
   selectedPanel: "main"
 });
+
+// src/index.ts
+init_constraints();
+
+// src/shared/lib/validation.ts
+function checkPrimitiveType(val, type) {
+  if (type === "array")
+    return Array.isArray(val);
+  if (type === "null")
+    return val === null;
+  if (type === "undefined")
+    return val === undefined;
+  return typeof val === type;
+}
+function checkFieldType(val, type) {
+  if (typeof type === "string") {
+    return checkPrimitiveType(val, type);
+  }
+  return validateShape(type)(val);
+}
+function validateShape(shape) {
+  return (value) => {
+    if (typeof value !== "object" || value === null)
+      return false;
+    const obj = value;
+    for (const [key, type] of Object.entries(shape)) {
+      if (!(key in obj))
+        return false;
+      if (!checkFieldType(obj[key], type))
+        return false;
+    }
+    return true;
+  };
+}
+function validateEnum(allowed) {
+  return (value) => {
+    return allowed.includes(value);
+  };
+}
+function validateArray(itemValidator) {
+  return (value) => {
+    if (!Array.isArray(value))
+      return false;
+    return value.every(itemValidator);
+  };
+}
+function validatePartial(_validator) {
+  return (value) => {
+    if (typeof value !== "object" || value === null)
+      return false;
+    return true;
+  };
+}
 export {
+  validateShape,
+  validatePartial,
+  validateEnum,
+  validateArray,
   settings,
   runInContext,
+  registerConstraints,
+  registerConstraint,
   quickTest,
+  isRuntimeConstraintsEnabled,
   getMessageBus,
   createTestSuite,
   createContext,
   createChromeAdapters,
+  clearConstraints,
+  checkPreconditions,
+  checkPostconditions,
   TimeoutError,
   TestRunner,
   MessageBus,
@@ -1525,4 +1725,4 @@ export {
   $persistedState
 };
 
-//# debugId=099A20C25FF495A164756E2164756E21
+//# debugId=20542B0975865A4164756E2164756E21