@fairfox/polly 0.12.3 → 0.13.0

package/dist/src/shared/lib/state.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,
@@ -1115,11 +1232,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, {
@@ -1129,11 +1251,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);
@@ -1169,6 +1296,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,
@@ -1201,6 +1332,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) {
@@ -1319,4 +1456,4 @@ export {
   $persistedState
 };
 
-//# debugId=085E9412FB1B6EF164756E2164756E21
+//# debugId=30E85DBFA071F76364756E2164756E21