@rpgjs/common 5.0.0-alpha.23 → 5.0.0-alpha.25

package/dist/index.js

@@ -1721,7 +1721,7 @@ var trackDependency = /* @__PURE__ */ __name$1((signal2) => {
     reactiveStore.currentDependencyTracker(signal2);
   }
 }, "trackDependency");
-function signal(defaultValue) {
+function signal(defaultValue, options) {
   let subject;
   if (Array.isArray(defaultValue)) {
     subject = new ArraySubject(defaultValue);
@@ -1743,12 +1743,21 @@ function signal(defaultValue) {
     return getValue();
   }, "fn");
   fn.set = (value) => {
-    if (subject instanceof ArraySubject) {
-      subject.items = value;
-    } else if (subject instanceof ObjectSubject) {
-      subject.obj = value;
+    const currentValue = getValue();
+    let shouldEmit = true;
+    if (options?.equal) {
+      shouldEmit = !options.equal(currentValue, value);
     } else {
-      subject.next(value);
+      shouldEmit = currentValue !== value;
+    }
+    if (shouldEmit) {
+      if (subject instanceof ArraySubject) {
+        subject.items = value;
+      } else if (subject instanceof ObjectSubject) {
+        subject.obj = value;
+      } else {
+        subject.next(value);
+      }
     }
   };
   fn._isFrozen = false;
@@ -1805,9 +1814,18 @@ function computed(computeFunction, disposableFn) {
     disposableFn = lastComputedValue;
   }
   reactiveStore.currentDependencyTracker = previousTracker;
-  const computedObservable = combineLatest([
+  const observables = [
     ...dependencies
-  ].map((signal2) => signal2.observable)).pipe(filter(() => !init), map(() => computeFunction()), finalize(() => disposableFn?.()));
+  ].map((dep) => {
+    if (isComputed(dep) && "dependencies" in dep) {
+      const computedDep = dep;
+      if (computedDep.dependencies.size === 0) {
+        return new BehaviorSubject(computedDep()).asObservable();
+      }
+    }
+    return dep.observable;
+  });
+  const computedObservable = combineLatest(observables).pipe(filter(() => !init), map(() => computeFunction()), finalize(() => disposableFn?.()));
   const fn = /* @__PURE__ */ __name$1(function() {
     trackDependency(fn);
     return lastComputedValue;
@@ -1822,6 +1840,193 @@ function computed(computeFunction, disposableFn) {
   return fn;
 }
 __name$1(computed, "computed");
+function linkedSignal(computationOrOptions, simpleOptions) {
+  const dependencies = /* @__PURE__ */ new Set();
+  let init = true;
+  let lastComputedValue;
+  let computeFunction;
+  let sourceSignal;
+  let computationFn;
+  let equalFn;
+  let previousValue;
+  let isOverridden = false;
+  let overriddenValue;
+  let depVersion = 0;
+  let overrideDepVersion = null;
+  if (typeof computationOrOptions === "function") {
+    computeFunction = computationOrOptions;
+    equalFn = simpleOptions?.equal;
+  } else {
+    const options = computationOrOptions;
+    sourceSignal = options.source;
+    computationFn = options.computation;
+    equalFn = options.equal;
+    if (typeof sourceSignal === "function" && !isSignal(sourceSignal)) {
+      const sourceFn = sourceSignal;
+      computeFunction = /* @__PURE__ */ __name$1(() => {
+        const sourceValue = sourceFn();
+        if (computationFn.length > 1) {
+          const result = computationFn(sourceValue, previousValue);
+          previousValue = {
+            source: sourceValue,
+            value: result
+          };
+          return result;
+        } else {
+          const result = computationFn(sourceValue);
+          previousValue = {
+            source: sourceValue,
+            value: result
+          };
+          return result;
+        }
+      }, "computeFunction");
+    } else {
+      const source = typeof sourceSignal === "function" ? sourceSignal : sourceSignal;
+      computeFunction = /* @__PURE__ */ __name$1(() => {
+        const sourceValue = source();
+        if (computationFn.length > 1) {
+          const result = computationFn(sourceValue, previousValue);
+          previousValue = {
+            source: sourceValue,
+            value: result
+          };
+          return result;
+        } else {
+          const result = computationFn(sourceValue);
+          previousValue = {
+            source: sourceValue,
+            value: result
+          };
+          return result;
+        }
+      }, "computeFunction");
+    }
+  }
+  const previousTracker = reactiveStore.currentDependencyTracker;
+  reactiveStore.currentDependencyTracker = (signal2) => {
+    dependencies.add(signal2);
+  };
+  if (sourceSignal && typeof sourceSignal === "function" && !isSignal(sourceSignal)) {
+    lastComputedValue = computeFunction();
+  } else if (sourceSignal && isSignal(sourceSignal)) {
+    dependencies.add(sourceSignal);
+    lastComputedValue = computeFunction();
+  } else {
+    lastComputedValue = computeFunction();
+  }
+  reactiveStore.currentDependencyTracker = previousTracker;
+  const subject = new BehaviorSubject(lastComputedValue);
+  const observables = [
+    ...dependencies
+  ].map((dep) => {
+    if (isComputed(dep) && "dependencies" in dep) {
+      const computedDep = dep;
+      if (computedDep.dependencies.size === 0) {
+        return new BehaviorSubject(computedDep()).asObservable();
+      }
+    }
+    return dep.observable;
+  });
+  let linkedObservable;
+  if (observables.length > 0) {
+    linkedObservable = combineLatest(observables).pipe(filter(() => !init), map(() => {
+      const computed2 = computeFunction();
+      if (equalFn) {
+        if (!equalFn(lastComputedValue, computed2)) {
+          lastComputedValue = computed2;
+          isOverridden = false;
+        }
+      } else {
+        if (lastComputedValue !== computed2) {
+          lastComputedValue = computed2;
+          isOverridden = false;
+        }
+      }
+      return lastComputedValue;
+    }));
+  } else {
+    linkedObservable = subject.asObservable().pipe(filter(() => !init));
+  }
+  const fn = /* @__PURE__ */ __name$1(function() {
+    trackDependency(fn);
+    if (isOverridden && dependencies.size > 0) {
+      if (overrideDepVersion !== depVersion) {
+        const computed2 = computeFunction();
+        isOverridden = false;
+        overriddenValue = void 0;
+        lastComputedValue = computed2;
+        overrideDepVersion = null;
+        return computed2;
+      }
+      return overriddenValue;
+    }
+    if (isOverridden) {
+      return overriddenValue;
+    }
+    if (dependencies.size === 0) {
+      const computed2 = computeFunction();
+      lastComputedValue = computed2;
+    }
+    return lastComputedValue;
+  }, "fn");
+  fn.observable = new Observable((observer) => {
+    const depSubscription = linkedObservable.subscribe((value) => {
+      if (dependencies.size > 0) {
+        depVersion++;
+        isOverridden = false;
+        overrideDepVersion = null;
+        lastComputedValue = value;
+      } else {
+        lastComputedValue = value;
+      }
+      observer.next(value);
+    });
+    let subjectSubscription;
+    if (dependencies.size === 0) {
+      subjectSubscription = subject.pipe(filter(() => !init)).subscribe((value) => {
+        observer.next(value);
+      });
+    }
+    observer.next(lastComputedValue);
+    return () => {
+      depSubscription.unsubscribe();
+      if (subjectSubscription) {
+        subjectSubscription.unsubscribe();
+      }
+    };
+  });
+  fn.subscription = fn.observable.subscribe(() => {
+  });
+  fn.dependencies = dependencies;
+  fn._subject = subject;
+  fn.set = (value) => {
+    if (!isOverridden) {
+      overrideDepVersion = depVersion;
+      if (computationFn && sourceSignal) {
+        const sourceValue = untracked(() => {
+          if (typeof sourceSignal === "function") {
+            const source = sourceSignal;
+            return isSignal(source) ? source() : sourceSignal();
+          }
+          return sourceSignal();
+        });
+        previousValue = {
+          source: sourceValue,
+          value
+        };
+      }
+    }
+    isOverridden = true;
+    overriddenValue = value;
+    lastComputedValue = value;
+    subject.next(value);
+  };
+  reactiveStore.currentSubscriptionsTracker?.(fn.subscription);
+  init = false;
+  return fn;
+}
+__name$1(linkedSignal, "linkedSignal");
 function untracked(fn) {
   const prevDepTracker = reactiveStore.currentDependencyTracker;
   const prevSubTracker = reactiveStore.currentSubscriptionsTracker;
@@ -2317,7 +2522,7 @@ class RpgCommonPlayer {
     this.hpSignal = signal(0);
     this.spSignal = signal(0);
     this._exp = signal(0);
-    this._level = signal(0);
+    this._level = signal(1);
     this._class = signal({});
     this.items = signal([]);
     this.equipments = signal([]);