@mmstack/primitives 19.6.0 → 19.7.1

package/lib/concurrent/index.d.ts

@@ -4,4 +4,5 @@ export * from './pausable';
 export * from './start-transition';
 export * from './suspense-boundary';
 export * from './transaction';
+export * from './transition';
 export * from './transition-scope';

package/lib/concurrent/start-transition.d.ts

@@ -1,7 +1,8 @@
 import { type Signal } from '@angular/core';
 /**
- * Handle for an in-progress transition: a `pending` signal (true while the transition's
- * resources are in flight) and a `done` promise that resolves once they all settle.
+ * Handle for an in-progress transition: a `pending` signal (true while the transition's OWN
+ * resources are in flight — loads already in flight when it started are not attributed) and a
+ * `done` promise that resolves once they all settle.
  */
 export type TransitionRef = {
     readonly pending: Signal<boolean>;

package/lib/concurrent/suspense-boundary.d.ts

@@ -41,8 +41,7 @@ export declare class SuspenseBoundary extends SuspenseBoundaryBase {
 }
 /**
  * Unscoped suspense boundary — **reads the ambient scope** instead of providing one. For cases where
- * the resources to coordinate are registered *above* the boundary (e.g. an app-builder page whose
- * manifests/connectors register at a higher injector), so the boundary observes that outer scope
+ * the resources to coordinate are registered *above* the boundary so the boundary observes that outer scope
  * rather than opening a fresh one. Pair with a `provideTransitionScope()` (or another boundary) in an
  * ancestor.
  */

package/lib/concurrent/transaction.d.ts

@@ -15,7 +15,8 @@ export type Transaction = {
 export declare function createTransaction(): Transaction;
 /** The transaction in effect right now, or `null`. Stateful actions consult this to record undo. */
 export declare function activeTransaction(): Transaction | null;
-/** Handle for an in-progress transaction (Tier 3): the transition `pending`/`done`, plus `abort`. */
+/** Handle for an in-progress transaction (Tier 3): the transaction's own `pending`/`done`
+ * (loads already in flight at start are not attributed to it), plus `abort`. */
 export type TransactionRef = {
     readonly pending: Signal<boolean>;
     readonly done: Promise<void>;

package/lib/concurrent/transition-scope.d.ts

@@ -78,6 +78,15 @@ export declare function createForwardingScope(): ForwardingTransitionScope;
 export declare function provideForwardingTransitionScope(): Provider;
 /** Read the transition scope reachable from `injector`, or null if none is provided there. */
 export declare function getTransitionScope(injector: Injector): TransitionScope | null;
+/**
+ * @internal Transaction-attributed pending for `startTransition`/`startTransaction`: like
+ * `scope.pending`, but loads already in flight when the tracker is created are NOT attributed —
+ * a pre-existing background load can neither settle the transaction early nor block its settle
+ * forever. A pre-existing flight is excluded only until it first settles; a later re-trigger of
+ * the same resource (e.g. the transaction's write changed its request) counts as the
+ * transaction's own work.
+ */
+export declare function createAttributedPending(scope: TransitionScope): Signal<boolean>;
 /**
  * Returns a register function bound to the nearest transition scope: it adds a resource
  * to the scope and removes it when the caller's injection context is destroyed. Pass any

package/lib/concurrent/transition.d.ts

@@ -0,0 +1,62 @@
+import { type Signal } from '@angular/core';
+import * as i0 from "@angular/core";
+export type MmTransitionContext<T> = {
+    readonly $implicit: T;
+    readonly mmTransition: T;
+};
+/**
+ * Generic hold-and-swap: the non-router `TransitionRouterOutlet`. When the bound value changes,
+ * the OLD view stays mounted and visible (it keeps its old context value — that's the hold) while
+ * the NEW view mounts hidden with its **own transition scope**; resources created in the incoming
+ * subtree register into that scope just by existing, and once they've gone in flight and settled
+ * the views swap in one frame. Tabs, wizard steps, master-detail — any branch change that would
+ * otherwise flash a loading state.
+ *
+ * ```html
+ * <div *mmTransition="selectedTab(); let tab">
+ *   @switch (tab) { ... }
+ * </div>
+ * ```
+ *
+ * Distinct from `<mm-suspense>` (the readiness gate): suspense decides placeholder-vs-content
+ * *within* one branch, but can't stop an `@switch` from unmounting the old branch the instant the
+ * value flips. This directive is the swap itself — the old branch survives until the new one is
+ * ready. Compose them freely: suspense inside a transitioned branch handles its first load.
+ *
+ * Semantics mirror the outlet: the first render is immediate (nothing to hold); an interrupting
+ * value change mid-hold destroys the half-ready hidden view and re-targets; a branch that loads
+ * nothing swaps right after its first render. Per-view scopes mean the outgoing branch's
+ * background work can never delay the swap. Set `mmTransitionImmediate` to skip holding, and
+ * `mmTransitionViewTransition` to wrap the swap in `document.startViewTransition` (feature
+ * detected). On the server every change swaps immediately.
+ */
+export declare class MmTransition<T> {
+    private readonly tpl;
+    private readonly vcr;
+    private readonly parent;
+    private readonly onServer;
+    /** The value whose changes are transitioned. Each view keeps the value it was created with. */
+    readonly value: import("@angular/core").InputSignal<T>;
+    /** Skip holding entirely — every change swaps at once (the plain re-render behavior). */
+    readonly immediate: import("@angular/core").InputSignal<boolean>;
+    /** Wrap the swap in the View Transitions API for an animated cross-fade (feature detected). */
+    readonly viewTransition: import("@angular/core").InputSignal<boolean>;
+    private current;
+    private incoming;
+    /** Bumped on every re-target/teardown so a superseded (possibly deferred) swap can't commit. */
+    private swapEpoch;
+    private readonly holding;
+    /** True while an incoming view is mounted hidden, waiting to settle. */
+    readonly pending: Signal<boolean>;
+    static ngTemplateContextGuard<T>(dir: MmTransition<T>, ctx: unknown): ctx is MmTransitionContext<T>;
+    constructor();
+    private onValue;
+    private commitSwap;
+    /** The actual swap: destroy the old view, reveal the new one. Always instant. */
+    private finishSwap;
+    private dropIncoming;
+    private createView;
+    private setHidden;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MmTransition<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MmTransition<any>, "[mmTransition]", ["mmTransition"], { "value": { "alias": "mmTransition"; "required": true; "isSignal": true; }; "immediate": { "alias": "mmTransitionImmediate"; "required": false; "isSignal": true; }; "viewTransition": { "alias": "mmTransitionViewTransition"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/sensors/pointer-drag.d.ts

@@ -33,6 +33,13 @@ export type PointerDragState = {
      * otherwise the listener's element. `null` when idle.
      */
     origin: HTMLElement | null;
+    /**
+     * Whether the LAST gesture ended by being aborted (`pointercancel` /
+     * `lostpointercapture` / Escape / `cancel()`) rather than a normal `pointerup`.
+     * Only meaningful on the idle transition — consumers ending a drag branch on it
+     * to distinguish "drop here" from "abort". Sticky until the next `pointerdown`.
+     */
+    cancelled: boolean;
 };
 export type PointerDragOptions = SensorRunOptions & {
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmstack/primitives",
-  "version": "19.6.0",
+  "version": "19.7.1",
   "keywords": [
     "angular",
     "signals",