octane 0.2.11 → 0.2.13

package/dist/cjs/signals/query-attempt-observer.cjs

@@ -0,0 +1,68 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var query_attempt_observer_exports = {};
+__export(query_attempt_observer_exports, {
+  captureCurrentServerSignalQueryAttemptObserver: () => captureCurrentServerSignalQueryAttemptObserver,
+  hasServerSignalQueryAttemptObserver: () => hasServerSignalQueryAttemptObserver,
+  runWithServerSignalQueryAttemptObserver: () => runWithServerSignalQueryAttemptObserver,
+  serverSignalQueryAttemptObserver: () => serverSignalQueryAttemptObserver
+});
+module.exports = __toCommonJS(query_attempt_observer_exports);
+let CURRENT_OBSERVER;
+function runWithServerSignalQueryAttemptObserver(owner, observe, createObservations, callback) {
+  const previous = CURRENT_OBSERVER;
+  CURRENT_OBSERVER = { owner, observe, createObservations };
+  try {
+    return callback();
+  } finally {
+    CURRENT_OBSERVER = previous;
+  }
+}
+function serverSignalQueryAttemptObserver(scopeKey) {
+  const context = CURRENT_OBSERVER;
+  if (context === void 0) return;
+  const ownerKey = context.owner.documentOwner.scopeKey;
+  if (scopeKey !== ownerKey && scopeKey !== `${ownerKey}:instance:${context.owner.instanceKey}`) {
+    return;
+  }
+  if (typeof context.createObservations !== "function") {
+    throw new TypeError("A server signal query observer requires an observation factory.");
+  }
+  return context;
+}
+function hasServerSignalQueryAttemptObserver(scopeKey) {
+  return serverSignalQueryAttemptObserver(scopeKey) !== void 0;
+}
+function captureCurrentServerSignalQueryAttemptObserver(scopeKey) {
+  const context = serverSignalQueryAttemptObserver(scopeKey);
+  if (context === void 0) return;
+  return (callback) => runWithServerSignalQueryAttemptObserver(
+    context.owner,
+    context.observe,
+    context.createObservations,
+    callback
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  captureCurrentServerSignalQueryAttemptObserver,
+  hasServerSignalQueryAttemptObserver,
+  runWithServerSignalQueryAttemptObserver,
+  serverSignalQueryAttemptObserver
+});

package/dist/cjs/signals/query-facade.cjs

@@ -0,0 +1,72 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var query_facade_exports = {};
+__export(query_facade_exports, {
+  __queryAt: () => __queryAt,
+  query$: () => query$
+});
+module.exports = __toCommonJS(query_facade_exports);
+var import_engine = require("./engine.cjs");
+var import_facade = require("./facade.cjs");
+var import_owner_context = require("./owner-context.cjs");
+var import_requests = require("./requests.cjs");
+var import_types = require("./types.cjs");
+class QueryDescriptor extends import_facade.Descriptor {
+  refetch() {
+    this.resolve().retry();
+  }
+  reset() {
+    this.resolve().retry({ pending: true });
+  }
+  retry(options) {
+    this.resolve().retry(options);
+  }
+}
+function __queryAt(site, select, load, options) {
+  if (typeof select !== "function" || typeof load !== "function") {
+    throw new TypeError("query$ requires selector and loader functions.");
+  }
+  const explicit = (0, import_facade.signalOptionsKey)(options);
+  site ??= explicit;
+  const authoredKey = (0, import_facade.descriptorKey)(site, explicit);
+  const key = explicit !== void 0 && (site?.startsWith("g:") || site?.startsWith("i:")) ? site.slice(0, 2) + authoredKey : authoredKey;
+  const request = (0, import_requests.query)(key, load, options);
+  return new QueryDescriptor(
+    key,
+    "async",
+    (owner) => (0, import_engine.createResourceCellWith)(
+      owner,
+      key,
+      () => {
+        const selection = (0, import_owner_context.runWithSignalOwner)(owner, select);
+        return selection === import_types.skip ? import_types.skip : request(selection);
+      },
+      import_requests.initializeResource
+    ),
+    site
+  );
+}
+function query$(select, load, options) {
+  return __queryAt(void 0, select, load, options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  __queryAt,
+  query$
+});

package/dist/cjs/signals/read-protocol.cjs

@@ -18,23 +18,67 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var read_protocol_exports = {};
 __export(read_protocol_exports, {
+  NATIVE_DOM_VALUE: () => NATIVE_DOM_VALUE,
+  NATIVE_TRANSITION_CONSUMER: () => NATIVE_TRANSITION_CONSUMER,
   NativeAdoptionMiss: () => NativeAdoptionMiss,
+  SIGNAL_DEPENDENT_NODE: () => SIGNAL_DEPENDENT_NODE,
   beginNativeBatch: () => beginNativeBatch,
   beginNativeWriteGuard: () => beginNativeWriteGuard,
   endNativeBatch: () => endNativeBatch,
   endNativeWriteGuard: () => endNativeWriteGuard,
+  forwardNativeTransitionConsumer: () => forwardNativeTransitionConsumer,
   getNativeAdoptionResolver: () => getNativeAdoptionResolver,
+  getNativeCandidate: () => getNativeCandidate,
   getNativeReadObserver: () => getNativeReadObserver,
   isNativeWriteGuarded: () => isNativeWriteGuarded,
+  readNativeDomProps: () => readNativeDomProps,
+  readNativeDomStyle: () => readNativeDomStyle,
+  readNativeDomValue: () => readNativeDomValue,
+  registerNativeActionResolver: () => registerNativeActionResolver,
   registerNativeBatchHooks: () => registerNativeBatchHooks,
   reportNativeRead: () => reportNativeRead,
   runNativeBatch: () => runNativeBatch,
   setNativeAdoptionResolver: () => setNativeAdoptionResolver,
+  setNativeCandidateResolver: () => setNativeCandidateResolver,
   setNativeReadObserver: () => setNativeReadObserver
 });
 module.exports = __toCommonJS(read_protocol_exports);
+const SIGNAL_DEPENDENT_NODE = /* @__PURE__ */ Symbol("octane.signalDependent");
+const NATIVE_TRANSITION_CONSUMER = /* @__PURE__ */ Symbol("octane.transitionConsumer");
+function forwardNativeTransitionConsumer(notify, wrapped) {
+  const consumer = notify[NATIVE_TRANSITION_CONSUMER];
+  if (consumer) wrapped[NATIVE_TRANSITION_CONSUMER] = consumer;
+  return wrapped;
+}
+let nativeActionResolver;
+let nativeCandidateResolver;
+function registerNativeActionResolver(resolver) {
+  nativeActionResolver = resolver;
+}
+function getNativeCandidate() {
+  return nativeCandidateResolver === void 0 ? nativeActionResolver?.() : nativeCandidateResolver?.();
+}
+function setNativeCandidateResolver(resolver) {
+  const previous = nativeCandidateResolver;
+  nativeCandidateResolver = resolver;
+  return previous;
+}
 let nativeReadObserver = null;
 let nativeWriteGuarded = false;
+const NATIVE_DOM_VALUE = /* @__PURE__ */ Symbol("octane.nativeDomValue");
+function readNativeDomValue(value) {
+  return value !== null && typeof value === "object" && NATIVE_DOM_VALUE in value ? value[NATIVE_DOM_VALUE]() : value;
+}
+function readNativeDomStyle(value) {
+  value = readNativeDomValue(value);
+  if (value === null || typeof value !== "object") return value;
+  const result = /* @__PURE__ */ Object.create(null);
+  for (const name in value) result[name] = readNativeDomValue(value[name]);
+  return result;
+}
+function readNativeDomProps(props) {
+  return "style" in props ? { ...props, style: readNativeDomStyle(props.style) } : props;
+}
 let nativeAdoptionResolver = null;
 class NativeAdoptionMiss extends Error {
   scopeKey;
@@ -100,17 +144,27 @@ function isNativeWriteGuarded() {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  NATIVE_DOM_VALUE,
+  NATIVE_TRANSITION_CONSUMER,
   NativeAdoptionMiss,
+  SIGNAL_DEPENDENT_NODE,
   beginNativeBatch,
   beginNativeWriteGuard,
   endNativeBatch,
   endNativeWriteGuard,
+  forwardNativeTransitionConsumer,
   getNativeAdoptionResolver,
+  getNativeCandidate,
   getNativeReadObserver,
   isNativeWriteGuarded,
+  readNativeDomProps,
+  readNativeDomStyle,
+  readNativeDomValue,
+  registerNativeActionResolver,
   registerNativeBatchHooks,
   reportNativeRead,
   runNativeBatch,
   setNativeAdoptionResolver,
+  setNativeCandidateResolver,
   setNativeReadObserver
 });