@mmstack/primitives 20.4.2 → 20.4.4

package/README.md

@@ -214,40 +214,30 @@ export class ThemeSelectorComponent {
 
 ### piped
 
-Adds a chainable .pipe(...) method to signals, allowing you to compose pure, synchronous transforms into reactive pipelines. Each .pipe(...) call returns a computed signal that is itself pipeable, so you can keep chaining.
+Adds two fluent APIs to signals:
 
-```typescript
-import { Component, effect } from '@angular/core';
-import { piped, pipeable } from '@mmstack/primitives';
+- **`.map(...transforms, [options])`** – compose pure, synchronous value→value transforms. Returns a computed signal that remains pipeable.
+- **`.pipe(...operators)`** – compose operators (signal→signal), useful for combining signals or reusable projections.
 
-@Component({
-  selector: 'app-pipeable',
-  template: `<button (click)="increment()">Increment</button>`,
-})
-export class PipeableComponent {
-  count = piped(1);
+```typescript
+import { piped, pipeable, select, combineWith } from '@mmstack/primitives';
+import { signal } from '@angular/core';
 
-  // Create a derived pipeline
-  label = this.count.pipe(
-    (n) => n * 2, // number -> number
-    (n) => `#${n}`, // number -> string
-  );
+const count = piped(1);
 
-  constructor() {
-    effect(() => {
-      console.log('Label:', this.label()); // e.g., "#2"
-    });
-  }
+// Map: value -> value
+const label = count.map(
+  (n) => n * 2,
+  (n) => (num: n),
+  { equal: (a, b) => a.num === b.num },
+);
 
-  increment() {
-    this.count.update((n) => n + 1);
-  }
-}
+// Pipe: signal -> signal
+const base = pipeable(signal(10));
+const total = count.pipe(select((n) => n * 3)).pipe(combineWith(count, (a, b) => a + b));
 
-// You can also transform existing signals into pipable versions
-const example = pipeable(computed(() => 1)); // PipeableSignal<number> (a readonly signal + pipe)
-const example2 = pipeable(signal(1)); // PipeableSignal<number, WritableSignal<number>> (a writable signal + pipe)
-const example3 = pipeable(mutable({ name: 'john' })); // This returns a pipeable mutable signal (you get the point :) )
+label(); // e.g., "#2"
+total(); // reactive sum
 ```
 
 ### mapArray

package/fesm2022/mmstack-primitives.mjs

@@ -477,6 +477,91 @@ function mapArray(source, map, options) {
     });
 }
 
+/** Project with optional equality. Pure & sync. */
+const select = (projector, opt) => (src) => computed(() => projector(src()), opt);
+/** Combine with another signal using a projector. */
+const combineWith = (other, project, opt) => (src) => computed(() => project(src(), other()), opt);
+/** Only re-emit when equal(prev, next) is false. */
+const distinct = (equal = Object.is) => (src) => computed(() => src(), { equal });
+/** map to new value */
+const map = (fn) => (src) => computed(() => fn(src()));
+/** filter values, keeping the last value if it was ever available, if first value is filtered will return undefined */
+const filter = (predicate) => (src) => linkedSignal({
+    source: src,
+    computation: (next, prev) => {
+        if (predicate(next))
+            return next;
+        return prev?.source;
+    },
+});
+/** tap into the value */
+const tap = (fn) => (src) => {
+    effect(() => fn(src()));
+    return src;
+};
+
+/**
+ * Decorate any `Signal<T>` with a chainable `.pipe(...)` method.
+ *
+ * @example
+ * const s = pipeable(signal(1)); // WritableSignal<number> (+ pipe)
+ * const label = s.pipe(n => n * 2, n => `#${n}`); // Signal<string> (+ pipe)
+ * label(); // "#2"
+ */
+function pipeable(signal) {
+    const internal = signal;
+    const mapImpl = (...fns) => {
+        const last = fns.at(-1);
+        let opt;
+        if (last && typeof last !== 'function') {
+            fns = fns.slice(0, -1);
+            opt = last;
+        }
+        if (fns.length === 0)
+            return internal;
+        if (fns.length === 1) {
+            const fn = fns[0];
+            return pipeable(computed(() => fn(internal()), opt));
+        }
+        const transformer = (input) => fns.reduce((acc, fn) => fn(acc), input);
+        return pipeable(computed(() => transformer(internal()), opt));
+    };
+    const pipeImpl = (...ops) => {
+        if (ops.length === 0)
+            return internal;
+        return ops.reduce((src, op) => pipeable(op(src)), internal);
+    };
+    Object.defineProperties(internal, {
+        map: {
+            value: mapImpl,
+            configurable: true,
+            enumerable: false,
+            writable: false,
+        },
+        pipe: {
+            value: pipeImpl,
+            configurable: true,
+            enumerable: false,
+            writable: false,
+        },
+    });
+    return internal;
+}
+/**
+ * Create a new **writable** signal and return it as a `PipableSignal`.
+ *
+ * The returned value is a `WritableSignal<T>` with `.set`, `.update`, `.asReadonly`
+ * still available (via intersection type), plus a chainable `.pipe(...)`.
+ *
+ * @example
+ * const count = piped(1); // WritableSignal<number> (+ pipe)
+ * const even = count.pipe(n => n % 2 === 0); // Signal<boolean> (+ pipe)
+ * count.update(n => n + 1);
+ */
+function piped(initial, opt) {
+    return pipeable(signal(initial, opt));
+}
+
 /**
  * Creates a read-only signal that reactively tracks whether a CSS media query
  * string currently matches.
@@ -1406,5 +1491,5 @@ function withHistory(source, opt) {
  * Generated bundle index. Do not edit.
  */
 
-export { debounce, debounced, derived, elementVisibility, isDerivation, isMutable, mapArray, mediaQuery, mousePosition, mutable, networkStatus, pageVisibility, prefersDarkMode, prefersReducedMotion, scrollPosition, sensor, stored, throttle, throttled, toFakeDerivation, toFakeSignalDerivation, toWritable, until, windowSize, withHistory };
+export { combineWith, debounce, debounced, derived, distinct, elementVisibility, filter, isDerivation, isMutable, map, mapArray, mediaQuery, mousePosition, mutable, networkStatus, pageVisibility, pipeable, piped, prefersDarkMode, prefersReducedMotion, scrollPosition, select, sensor, stored, tap, throttle, throttled, toFakeDerivation, toFakeSignalDerivation, toWritable, until, windowSize, withHistory };
 //# sourceMappingURL=mmstack-primitives.mjs.map