foldkit 0.137.0 → 0.138.0

package/dist/runtime/viewTransition.d.ts

@@ -0,0 +1,69 @@
+import { Option } from 'effect';
+/** Context passed to the `viewTransition` predicate before each live render.
+ *
+ *  A View Transition animates between two states, so the predicate is given
+ *  both. `previousModel` is the Model behind the DOM on screen, the state the
+ *  browser is about to snapshot. `model` is the Model the pending render will
+ *  paint. Direction is the pair: comparing the two says where the application
+ *  is going and where it came from, with no route history kept in the Model.
+ *
+ *  `previousModel` is always a real painted state rather than an `Option`. The
+ *  predicate only runs once a Message has dirtied the Model, and the initial
+ *  render completes before any Message is processed.
+ *
+ *  `message` is the Message that dirtied the Model for this frame. The runtime
+ *  coalesces a burst of dispatches into one render frame, so the predicate
+ *  sees the last dirtying Message before the frame. */
+export type ViewTransitionContext<Model, Message> = Readonly<{
+    previousModel: Model;
+    model: Model;
+    message: Message;
+}>;
+/** What the `viewTransition` predicate returns for a render. `false` renders
+ *  plainly. `true` wraps the render in `document.startViewTransition`.
+ *  `{ types }` additionally tags the transition so CSS can scope animations
+ *  via `:active-view-transition-type(...)`. */
+export type ViewTransitionDecision = boolean | Readonly<{
+    types: ReadonlyArray<string>;
+}>;
+/** Decides, per render, whether the DOM update should run inside a View
+ *  Transition. The predicate is total over the Message union, so animation is
+ *  opted into per Message: return `true` for the ones worth animating and
+ *  `false` for everything else. */
+export type ViewTransitionConfig<Model, Message> = (context: ViewTransitionContext<Model, Message>) => ViewTransitionDecision;
+/** The slice of the DOM `ViewTransition` handle the runtime consumes. `ready`
+ *  and `finished` are optional: the runtime only ever attaches rejection
+ *  handlers to them, so a handle that omits them stays valid. */
+export type ViewTransitionHandle = Readonly<{
+    updateCallbackDone: Promise<void>;
+    skipTransition: () => void;
+    ready?: Promise<void>;
+    finished?: Promise<void>;
+}>;
+/**
+ * Attaches no-op rejection handlers to a transition's promises.
+ *
+ * The browser rejects `ready` whenever a transition is skipped, and skipping
+ * is routine rather than exceptional: a second navigation lands mid-animation,
+ * the document is hidden, or the runtime skips the transition itself while
+ * tearing down. The runtime never awaits any of these promises, so without a
+ * handler every skip surfaces as an unhandled rejection and lands in whatever
+ * the application wired to `window.onunhandledrejection`, turning a purely
+ * cosmetic animation into an error report.
+ */
+export declare const __silenceViewTransitionRejections: (handle: ViewTransitionHandle) => void;
+/** Starts a View Transition around `update`. Injected into the render path so
+ *  tests can fake the browser API. */
+export type StartViewTransition = (update: () => void, maybeTypes: Option.Option<ReadonlyArray<string>>) => ViewTransitionHandle;
+/** Feature-detects `document.startViewTransition`, returning `Option.none()`
+ *  where the API is unavailable so the runtime falls through to plain
+ *  renders. Transition types are newer than the API itself, so when the
+ *  running browser only supports the callback form the types are dropped and
+ *  the transition still runs untyped. */
+export declare const __resolveStartViewTransition: () => Option.Option<StartViewTransition>;
+/** Normalizes a `ViewTransitionDecision` into "skip" (`Option.none()`) or
+ *  "transition, with these types" so the render path branches once. */
+export declare const __decideViewTransition: <Model, Message>(decide: ViewTransitionConfig<Model, Message>, context: ViewTransitionContext<Model, Message>) => Option.Option<Readonly<{
+    maybeTypes: Option.Option<ReadonlyArray<string>>;
+}>>;
+//# sourceMappingURL=viewTransition.d.ts.map

package/dist/runtime/viewTransition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"viewTransition.d.ts","sourceRoot":"","sources":["../../src/runtime/viewTransition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,MAAM,EAAQ,MAAM,QAAQ,CAAA;AAE5C;;;;;;;;;;;;;;uDAcuD;AACvD,MAAM,MAAM,qBAAqB,CAAC,KAAK,EAAE,OAAO,IAAI,QAAQ,CAAC;IAC3D,aAAa,EAAE,KAAK,CAAA;IACpB,KAAK,EAAE,KAAK,CAAA;IACZ,OAAO,EAAE,OAAO,CAAA;CACjB,CAAC,CAAA;AAEF;;;+CAG+C;AAC/C,MAAM,MAAM,sBAAsB,GAC9B,OAAO,GACP,QAAQ,CAAC;IAAE,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CAAE,CAAC,CAAA;AAE9C;;;mCAGmC;AACnC,MAAM,MAAM,oBAAoB,CAAC,KAAK,EAAE,OAAO,IAAI,CACjD,OAAO,EAAE,qBAAqB,CAAC,KAAK,EAAE,OAAO,CAAC,KAC3C,sBAAsB,CAAA;AAE3B;;iEAEiE;AACjE,MAAM,MAAM,oBAAoB,GAAG,QAAQ,CAAC;IAC1C,kBAAkB,EAAE,OAAO,CAAC,IAAI,CAAC,CAAA;IACjC,cAAc,EAAE,MAAM,IAAI,CAAA;IAC1B,KAAK,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,CAAA;IACrB,QAAQ,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,CAAA;CACzB,CAAC,CAAA;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iCAAiC,GAC5C,QAAQ,oBAAoB,KAC3B,IAKF,CAAA;AAED;sCACsC;AACtC,MAAM,MAAM,mBAAmB,GAAG,CAChC,MAAM,EAAE,MAAM,IAAI,EAClB,UAAU,EAAE,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,KAC7C,oBAAoB,CAAA;AAEzB;;;;yCAIyC;AACzC,eAAO,MAAM,4BAA4B,QACnC,MAAM,CAAC,MAAM,CAAC,mBAAmB,CAoBpC,CAAA;AAEH;uEACuE;AACvE,eAAO,MAAM,sBAAsB,GAAI,KAAK,EAAE,OAAO,EACnD,QAAQ,oBAAoB,CAAC,KAAK,EAAE,OAAO,CAAC,EAC5C,SAAS,qBAAqB,CAAC,KAAK,EAAE,OAAO,CAAC,KAC7C,MAAM,CAAC,MAAM,CACd,QAAQ,CAAC;IAAE,UAAU,EAAE,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAA;CAAE,CAAC,CAa7D,CAAA"}

package/dist/runtime/viewTransition.js

@@ -0,0 +1,37 @@
+import { Match, Option, pipe } from 'effect';
+/**
+ * Attaches no-op rejection handlers to a transition's promises.
+ *
+ * The browser rejects `ready` whenever a transition is skipped, and skipping
+ * is routine rather than exceptional: a second navigation lands mid-animation,
+ * the document is hidden, or the runtime skips the transition itself while
+ * tearing down. The runtime never awaits any of these promises, so without a
+ * handler every skip surfaces as an unhandled rejection and lands in whatever
+ * the application wired to `window.onunhandledrejection`, turning a purely
+ * cosmetic animation into an error report.
+ */
+export const __silenceViewTransitionRejections = (handle) => {
+    const ignore = () => { };
+    handle.ready?.catch(ignore);
+    handle.finished?.catch(ignore);
+    handle.updateCallbackDone.catch(ignore);
+};
+/** Feature-detects `document.startViewTransition`, returning `Option.none()`
+ *  where the API is unavailable so the runtime falls through to plain
+ *  renders. Transition types are newer than the API itself, so when the
+ *  running browser only supports the callback form the types are dropped and
+ *  the transition still runs untyped. */
+export const __resolveStartViewTransition = () => {
+    if (typeof document.startViewTransition !== 'function') {
+        return Option.none();
+    }
+    const isTypesSupported = typeof ViewTransition !== 'undefined' &&
+        'types' in ViewTransition.prototype;
+    return Option.some((update, maybeTypes) => pipe(maybeTypes, Option.filter(() => isTypesSupported), Option.match({
+        onNone: () => document.startViewTransition(update),
+        onSome: types => document.startViewTransition({ update, types: [...types] }),
+    })));
+};
+/** Normalizes a `ViewTransitionDecision` into "skip" (`Option.none()`) or
+ *  "transition, with these types" so the render path branches once. */
+export const __decideViewTransition = (decide, context) => Match.value(decide(context)).pipe(Match.withReturnType(), Match.when(false, () => Option.none()), Match.when(true, () => Option.some({ maybeTypes: Option.none() })), Match.orElse(({ types }) => Option.some({ maybeTypes: Option.some(types) })));

package/dist/test/apps/attributes.js

@@ -11,5 +11,5 @@ export const update = (model, message) => M.value(message).pipe(M.withReturnType
 const TEST_ID = 'attribute-host';
 export const testId = TEST_ID;
 export const view = (model, h) => {
-    return h.div([h.DataAttribute('testid', TEST_ID), model.attribute], []);
+    return h.div([h.DataAttribute('testid', TEST_ID), model.attribute]);
 };

package/dist/test/apps/mountPanel.js

@@ -88,5 +88,5 @@ export const twoPanelView = (model, h) => {
  *  pending Mount's args). The chosen `offset` flows through `ScrollList`'s
  *  args and is observable on the rendered Mount marker. */
 export const scrollListView = (offset, h) => {
-    return h.div([h.Class('scroll-list')], [h.div([h.Key('list'), h.OnMount(ScrollList({ offset }))], [])]);
+    return h.div([h.Class('scroll-list')], [h.div([h.Key('list'), h.OnMount(ScrollList({ offset }))])]);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "foldkit",
-  "version": "0.137.0",
+  "version": "0.138.0",
   "description": "A TypeScript frontend framework, built on Effect and architected like Elm",
   "type": "module",
   "main": "./dist/index.js",