@absolutejs/absolute 0.19.0-beta.868 → 0.19.0-beta.869

package/dist/angular/components/core/streamingSlotRegistrar.js

@@ -1,7 +1,7 @@
 // @bun
 var __require = import.meta.require;
 
-// .angular-partial-tmp-V8Evbn/src/core/streamingSlotRegistrar.ts
+// .angular-partial-tmp-qkUlea/src/core/streamingSlotRegistrar.ts
 var STREAMING_SLOT_REGISTRAR_KEY = Symbol.for("absolutejs.streamingSlotRegistrar");
 var STREAMING_SLOT_WARNING_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotWarningController");
 var STREAMING_SLOT_COLLECTION_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotCollectionController");

package/dist/angular/components/core/streamingSlotRegistry.js

@@ -1,7 +1,7 @@
 // @bun
 var __require = import.meta.require;
 
-// .angular-partial-tmp-V8Evbn/src/core/streamingSlotRegistrar.ts
+// .angular-partial-tmp-qkUlea/src/core/streamingSlotRegistrar.ts
 var STREAMING_SLOT_REGISTRAR_KEY = Symbol.for("absolutejs.streamingSlotRegistrar");
 var STREAMING_SLOT_WARNING_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotWarningController");
 var STREAMING_SLOT_COLLECTION_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotCollectionController");
@@ -48,7 +48,7 @@ var warnMissingStreamingSlotCollector = (primitiveName) => {
   getWarningController()?.maybeWarn(primitiveName);
 };
 
-// .angular-partial-tmp-V8Evbn/src/core/streamingSlotRegistry.ts
+// .angular-partial-tmp-qkUlea/src/core/streamingSlotRegistry.ts
 var STREAMING_SLOT_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotAsyncLocalStorage");
 var isObjectRecord2 = (value) => Boolean(value) && typeof value === "object";
 var isAsyncLocalStorage = (value) => isObjectRecord2(value) && ("getStore" in value) && typeof value.getStore === "function" && ("run" in value) && typeof value.run === "function";

package/dist/dev/client/handlers/angularRemount.ts

@@ -29,14 +29,12 @@ import type {} from '../../../types/globals';
  *     known limitation in ANGULAR_PER_COMPONENT_REMOUNT_RESEARCH.md. */
 
 import {
-	CHILD_HEAD,
-	CHILD_TAIL,
 	CONTEXT,
 	HOST,
 	PARENT,
 	T_HOST,
 	TVIEW
-} from '../../angular/vendor/lview/slotConstants';
+} from '../vendor/lview/slotConstants';
 import {
 	executeOnDestroys,
 	isLView,
@@ -46,7 +44,7 @@ import {
 	type LView,
 	type TView,
 	type TNode
-} from '../../angular/vendor/lview/lViewOps';
+} from '../vendor/lview/lViewOps';
 
 type AngularCoreNamespace = {
 	createComponent: (

package/dist/dev/client/vendor/lview/lViewOps.ts

@@ -0,0 +1,194 @@
+import type {} from '../../../../types/globals';
+/* Vendored LView slot operations. Direct port from
+ * `@angular/core/fesm2022/_debug_node-chunk.mjs` of the small-and-pure
+ * helpers we need for per-component remount. The big helpers
+ * (renderView / refreshView / destroyLView's full DOM-removal path)
+ * stay in Angular — we invoke them indirectly via public
+ * `createComponent`. The ones here are slot-manipulation primitives
+ * with no transitive dependencies, so vendoring them is safe.
+ *
+ * Per-Angular-version chore: re-diff against the upstream functions
+ * after each minor bump. They've been stable since v17 — the algorithm
+ * shape hasn't changed since the LView FLAGS reshuffle. */
+
+import {
+	CHILD_HEAD,
+	CHILD_TAIL,
+	CLEANUP,
+	FLAGS,
+	HEADER_OFFSET,
+	LFLAG_DESTROYED,
+	NEXT,
+	ON_DESTROY_HOOKS,
+	TVIEW
+} from './slotConstants';
+
+export type LView = unknown[];
+export type LContainer = unknown[];
+export type TView = {
+	bindingStartIndex: number;
+	cleanup: unknown[] | null;
+	destroyHooks: unknown[] | null;
+};
+export type TNode = { index: number };
+
+/* `isLView` / `isLContainer` shape checks. The runtime distinguishes
+ * by whether slot 1 (TVIEW) is an object or undefined — LContainer
+ * doesn't have a TView. */
+export const isLView = (v: unknown): v is LView =>
+	Array.isArray(v) && typeof (v as unknown[])[TVIEW] === 'object';
+
+export const isLContainer = (v: unknown): v is LContainer =>
+	Array.isArray(v) && (v as unknown[])[TVIEW] === undefined;
+
+export const isDestroyed = (lView: LView): boolean =>
+	((lView[FLAGS] as number) & LFLAG_DESTROYED) !== 0;
+
+/* Vendored from `replaceLViewInTree(parentLView, oldLView, newLView, index)`.
+ * Walks parent's slots looking for the LView/LContainer whose NEXT
+ * pointer is `oldLView` and rewires it to `newLView`, then patches
+ * CHILD_HEAD / CHILD_TAIL if `oldLView` was at either end, and finally
+ * places `newLView` at the indexed slot.
+ *
+ * Verbatim port — keep it that way to make diff-against-upstream cheap. */
+export const replaceLViewInTree = (
+	parentLView: LView,
+	oldLView: LView,
+	newLView: LView,
+	index: number
+): void => {
+	const parentTView = parentLView[TVIEW] as TView;
+	for (let i = HEADER_OFFSET; i < parentTView.bindingStartIndex; i++) {
+		const current = parentLView[i];
+		if (
+			(isLView(current) || isLContainer(current)) &&
+			(current as LView)[NEXT] === oldLView
+		) {
+			(current as LView)[NEXT] = newLView;
+			break;
+		}
+	}
+	if (parentLView[CHILD_HEAD] === oldLView) parentLView[CHILD_HEAD] = newLView;
+	if (parentLView[CHILD_TAIL] === oldLView) parentLView[CHILD_TAIL] = newLView;
+	newLView[NEXT] = oldLView[NEXT];
+	oldLView[NEXT] = null;
+	parentLView[index] = newLView;
+};
+
+/* Vendored from `executeOnDestroys(tView, lView)`. tView.destroyHooks
+ * is laid out as `[slotIdx, hook | hookList, slotIdx, hook | hookList, ...]`.
+ * Each `hook` is either a function (called with `lView[slotIdx]` as
+ * `this`) or an array of `[propertyKey, fn]` pairs (one per directive
+ * sharing the slot). NodeInjectorFactory contexts are skipped; they
+ * represent injector providers, not directive instances. */
+type NodeInjectorFactoryLike = { multi?: unknown };
+
+const isNodeInjectorFactoryLike = (
+	value: unknown
+): value is NodeInjectorFactoryLike =>
+	typeof value === 'object' &&
+	value !== null &&
+	value.constructor !== undefined &&
+	value.constructor.name === 'NodeInjectorFactory';
+
+export const executeOnDestroys = (tView: TView, lView: LView): void => {
+	const destroyHooks = tView.destroyHooks;
+	if (destroyHooks == null) return;
+
+	for (let i = 0; i < destroyHooks.length; i += 2) {
+		const slotIdx = destroyHooks[i] as number;
+		const context = lView[slotIdx];
+		if (isNodeInjectorFactoryLike(context)) continue;
+
+		const toCall = destroyHooks[i + 1];
+		if (Array.isArray(toCall)) {
+			for (let j = 0; j < toCall.length; j += 2) {
+				const propKey = toCall[j] as string;
+				const hook = toCall[j + 1] as () => void;
+				const callContext = (context as Record<string, unknown>)[propKey];
+				try {
+					hook.call(callContext);
+				} catch (err) {
+					console.error('[absolutejs] onDestroy hook threw', err);
+				}
+			}
+		} else if (typeof toCall === 'function') {
+			try {
+				(toCall as (this: unknown) => void).call(context);
+			} catch (err) {
+				console.error('[absolutejs] onDestroy hook threw', err);
+			}
+		}
+	}
+};
+
+/* Vendored from `processCleanups(tView, lView)`. Walks tView.cleanup which
+ * is laid out as either:
+ *   [eventName(string), targetIdx, listenerIdx, indirectIdx, ...]
+ *     — DOM event listener; lCleanup[indirectIdx] is the unregister fn
+ *       (or, if indirectIdx is negative, lCleanup[-indirectIdx] is a
+ *       Subscription whose .unsubscribe() we call)
+ *   [hookFn(function), contextSlotIdx, ...]
+ *     — directive output / cleanup callback; call hookFn with
+ *       lCleanup[contextSlotIdx] as `this`
+ * Then walks lView[ON_DESTROY_HOOKS] (component-level destroy hooks,
+ * registered via `inject(DestroyRef).onDestroy(...)` etc.) and fires
+ * each one. */
+export const processCleanups = (tView: TView, lView: LView): void => {
+	const tCleanup = tView.cleanup;
+	const lCleanup = lView[CLEANUP] as unknown[] | null;
+
+	if (tCleanup !== null && lCleanup !== null) {
+		for (let i = 0; i < tCleanup.length - 1; i += 2) {
+			const entry = tCleanup[i];
+			if (typeof entry === 'string') {
+				const targetIdx = tCleanup[i + 3] as number;
+				try {
+					if (targetIdx >= 0) {
+						(lCleanup[targetIdx] as () => void)();
+					} else {
+						(
+							lCleanup[-targetIdx] as { unsubscribe: () => void }
+						).unsubscribe();
+					}
+				} catch (err) {
+					console.error('[absolutejs] DOM cleanup threw', err);
+				}
+				i += 2;
+			} else if (typeof entry === 'function') {
+				const ctxIdx = tCleanup[i + 1] as number;
+				try {
+					(entry as (this: unknown) => void).call(lCleanup[ctxIdx]);
+				} catch (err) {
+					console.error('[absolutejs] cleanup callback threw', err);
+				}
+			}
+		}
+	}
+
+	if (lCleanup !== null) {
+		lView[CLEANUP] = null;
+	}
+
+	const onDestroyHooks = lView[ON_DESTROY_HOOKS] as
+		| Array<() => void>
+		| null;
+	if (onDestroyHooks !== null) {
+		lView[ON_DESTROY_HOOKS] = null;
+		for (const hook of onDestroyHooks) {
+			try {
+				hook();
+			} catch (err) {
+				console.error('[absolutejs] DestroyRef hook threw', err);
+			}
+		}
+	}
+};
+
+/* Mark an LView as destroyed so any later
+ * destroyLView/cleanUpView no-ops it. Without this flag the LView
+ * could get walked twice (e.g. if Angular's tree-walk later finds
+ * a stale reference). */
+export const markLViewDestroyed = (lView: LView): void => {
+	lView[FLAGS] = ((lView[FLAGS] as number) | LFLAG_DESTROYED) >>> 0;
+};

package/dist/dev/client/vendor/lview/slotConstants.ts

@@ -0,0 +1,44 @@
+import type {} from '../../../../types/globals';
+/* Vendored LView slot indices from `@angular/core`. The runtime represents
+ * each LView as a flat array; these constants name the structural slots
+ * before the per-template slots start at HEADER_OFFSET.
+ *
+ * Source: `node_modules/@angular/core/fesm2022/_effect-chunk2.mjs`
+ * (search for `const HOST = 0;`). These are NOT exported and Angular keeps
+ * them tightly held — but they have not shifted since the v9 ivy rewrite,
+ * so the maintenance cost is verifying once per Angular minor that
+ *   `_effect-chunk2.mjs:HOST === 0` etc. still holds.
+ *
+ * If Angular reorders these, our LView traversal returns wrong slots
+ * (e.g. reading PARENT might yield CONTEXT). Symptom: per-component
+ * remount throws or silently swaps the wrong subtree. Verify at the
+ * top of `angularRemount.ts` via shape checks before doing anything
+ * destructive. */
+
+export const HOST = 0;
+export const TVIEW = 1;
+export const FLAGS = 2;
+export const PARENT = 3;
+export const NEXT = 4;
+export const T_HOST = 5;
+export const HYDRATION = 6;
+export const CLEANUP = 7;
+export const CONTEXT = 8;
+export const INJECTOR = 9;
+export const ENVIRONMENT = 10;
+export const RENDERER = 11;
+export const CHILD_HEAD = 12;
+export const CHILD_TAIL = 13;
+export const DECLARATION_VIEW = 14;
+export const DECLARATION_COMPONENT_VIEW = 15;
+export const DECLARATION_LCONTAINER = 16;
+export const PREORDER_HOOK_FLAGS = 17;
+export const QUERIES = 18;
+export const ID = 19;
+export const EMBEDDED_VIEW_INJECTOR = 20;
+export const ON_DESTROY_HOOKS = 21;
+export const HEADER_OFFSET = 27;
+
+/* LView FLAGS bitfield bits (from same source). We only care about
+ * the destroyed bit so that double-destroy is a no-op. */
+export const LFLAG_DESTROYED = 256;

package/package.json

@@ -385,5 +385,5 @@
 			]
 		}
 	},
-	"version": "0.19.0-beta.868"
+	"version": "0.19.0-beta.869"
 }

package/dist/src/dev/angular/vendor/lview/lViewOps.d.ts

@@ -1,17 +0,0 @@
-export type LView = unknown[];
-export type LContainer = unknown[];
-export type TView = {
-    bindingStartIndex: number;
-    cleanup: unknown[] | null;
-    destroyHooks: unknown[] | null;
-};
-export type TNode = {
-    index: number;
-};
-export declare const isLView: (v: unknown) => v is LView;
-export declare const isLContainer: (v: unknown) => v is LContainer;
-export declare const isDestroyed: (lView: LView) => boolean;
-export declare const replaceLViewInTree: (parentLView: LView, oldLView: LView, newLView: LView, index: number) => void;
-export declare const executeOnDestroys: (tView: TView, lView: LView) => void;
-export declare const processCleanups: (tView: TView, lView: LView) => void;
-export declare const markLViewDestroyed: (lView: LView) => void;

package/dist/src/dev/angular/vendor/lview/slotConstants.d.ts

@@ -1,24 +0,0 @@
-export declare const HOST = 0;
-export declare const TVIEW = 1;
-export declare const FLAGS = 2;
-export declare const PARENT = 3;
-export declare const NEXT = 4;
-export declare const T_HOST = 5;
-export declare const HYDRATION = 6;
-export declare const CLEANUP = 7;
-export declare const CONTEXT = 8;
-export declare const INJECTOR = 9;
-export declare const ENVIRONMENT = 10;
-export declare const RENDERER = 11;
-export declare const CHILD_HEAD = 12;
-export declare const CHILD_TAIL = 13;
-export declare const DECLARATION_VIEW = 14;
-export declare const DECLARATION_COMPONENT_VIEW = 15;
-export declare const DECLARATION_LCONTAINER = 16;
-export declare const PREORDER_HOOK_FLAGS = 17;
-export declare const QUERIES = 18;
-export declare const ID = 19;
-export declare const EMBEDDED_VIEW_INJECTOR = 20;
-export declare const ON_DESTROY_HOOKS = 21;
-export declare const HEADER_OFFSET = 27;
-export declare const LFLAG_DESTROYED = 256;