typegpu 0.11.9 → 0.12.1

package/data/offsetUtils.d.ts

@@ -1,16 +1,14 @@
-import { BaseData } from "./wgslTypes.js";
-import { Infer } from "../shared/repr.js";
-
-//#region src/data/offsetUtils.d.ts
-
+import type { BaseData } from './wgslTypes.ts';
+import type { Infer } from '../shared/repr.ts';
+export declare function createOffsetProxy<T extends BaseData>(schema: T, baseOffset?: number): unknown;
 /**
  * Interface containing information about the offset and the available contiguous after a selected primitive.
  */
-interface PrimitiveOffsetInfo {
-  /** The byte offset of the primitive within the buffer. */
-  offset: number;
-  /** The number of contiguous bytes available from the offset. */
-  contiguous: number;
+export interface PrimitiveOffsetInfo {
+    /** The byte offset of the primitive within the buffer. */
+    offset: number;
+    /** The number of contiguous bytes available from the offset. */
+    contiguous: number;
 }
 /**
  * A function that retrieves offset and information for a specific primitive within a data schema.
@@ -29,6 +27,4 @@ interface PrimitiveOffsetInfo {
  * @param accessor - Optional function that accesses a specific element within the schema. If omitted, uses the root offset (0).
  * @returns An object containing the offset and contiguous byte information.
  */
-declare function memoryLayoutOf<T extends BaseData>(schema: T, accessor?: (proxy: Infer<T>) => unknown): PrimitiveOffsetInfo;
-//#endregion
-export { PrimitiveOffsetInfo, memoryLayoutOf };
+export declare function memoryLayoutOf<T extends BaseData>(schema: T, accessor?: (proxy: Infer<T>) => unknown): PrimitiveOffsetInfo;

package/data/offsetUtils.js

@@ -1,167 +1,227 @@
-import { isVec, isWgslArray, isWgslStruct } from "./wgslTypes.js";
-import { undecorate } from "./dataTypes.js";
-import { alignmentOf } from "./alignmentOf.js";
 import { roundUp } from "../mathUtils.js";
-import { sizeOf } from "./sizeOf.js";
+import { alignmentOf } from "./alignmentOf.js";
 import { offsetsForProps } from "./offsets.js";
+import { sizeOf } from "./sizeOf.js";
 import { isContiguous } from "./isContiguous.js";
 import { getLongestContiguousPrefix } from "./getLongestContiguousPrefix.js";
-
-//#region src/data/offsetUtils.ts
-const OFFSET_MARKER = Symbol("indirectOffset");
-const CONTIGUOUS_MARKER = Symbol("indirectContiguous");
+import { isVec, isWgslArray, isWgslStruct } from "./wgslTypes.js";
+import { undecorate } from "./dataTypes.js";
+const OFFSET_MARKER = Symbol('indirectOffset');
+const CONTIGUOUS_MARKER = Symbol('indirectContiguous');
 function isOffsetProxy(value) {
-	return typeof value === "object" && value !== null && OFFSET_MARKER in value && CONTIGUOUS_MARKER in value;
+    return (typeof value === 'object' &&
+        value !== null &&
+        OFFSET_MARKER in value &&
+        CONTIGUOUS_MARKER in value);
 }
 function scalarNode(offset, contiguous) {
-	return {
-		[OFFSET_MARKER]: offset,
-		[CONTIGUOUS_MARKER]: contiguous
-	};
+    return { [OFFSET_MARKER]: offset, [CONTIGUOUS_MARKER]: contiguous };
 }
 function getMarker(target, prop) {
-	if (prop === OFFSET_MARKER) return target[OFFSET_MARKER];
-	if (prop === CONTIGUOUS_MARKER) return target[CONTIGUOUS_MARKER];
+    if (prop === OFFSET_MARKER) {
+        return target[OFFSET_MARKER];
+    }
+    if (prop === CONTIGUOUS_MARKER) {
+        return target[CONTIGUOUS_MARKER];
+    }
+    return undefined;
 }
 function makeProxy(schema, baseOffset, contiguous = sizeOf(schema)) {
-	const unwrapped = undecorate(schema);
-	const vecComponentCount = isVec(unwrapped) ? unwrapped.componentCount : void 0;
-	if (vecComponentCount !== void 0) {
-		const componentSize = sizeOf(unwrapped.primitive);
-		return makeVecProxy(scalarNode(baseOffset, contiguous), componentSize, vecComponentCount);
-	}
-	if (isWgslStruct(unwrapped)) return makeStructProxy(unwrapped, scalarNode(baseOffset, contiguous));
-	if (isWgslArray(unwrapped)) return makeArrayProxy(unwrapped, scalarNode(baseOffset, contiguous));
-	return scalarNode(baseOffset, contiguous);
+    const unwrapped = undecorate(schema);
+    const vecComponentCount = isVec(unwrapped) ? unwrapped.componentCount : undefined;
+    if (vecComponentCount !== undefined) {
+        const componentSize = sizeOf(unwrapped.primitive);
+        return makeVecProxy(scalarNode(baseOffset, contiguous), componentSize, vecComponentCount);
+    }
+    if (isWgslStruct(unwrapped)) {
+        return makeStructProxy(unwrapped, scalarNode(baseOffset, contiguous));
+    }
+    if (isWgslArray(unwrapped)) {
+        return makeArrayProxy(unwrapped, scalarNode(baseOffset, contiguous));
+    }
+    return scalarNode(baseOffset, contiguous);
 }
-function createOffsetProxy(schema, baseOffset = 0) {
-	return makeProxy(schema, baseOffset, sizeOf(schema));
+export function createOffsetProxy(schema, baseOffset = 0) {
+    return makeProxy(schema, baseOffset, sizeOf(schema));
 }
 function makeVecProxy(target, componentSize, componentCount) {
-	const baseOffset = target[OFFSET_MARKER];
-	return new Proxy(target, { get(t, prop) {
-		const marker = getMarker(t, prop);
-		if (marker !== void 0) return marker;
-		const idx = prop === "x" || prop === "0" ? 0 : prop === "y" || prop === "1" ? 1 : prop === "z" || prop === "2" ? 2 : prop === "w" || prop === "3" ? 3 : -1;
-		if (idx < 0 || idx >= componentCount) return;
-		const byteOffset = idx * componentSize;
-		const contiguous = Math.max(0, t[CONTIGUOUS_MARKER] - byteOffset);
-		return scalarNode(baseOffset + byteOffset, contiguous);
-	} });
+    const baseOffset = target[OFFSET_MARKER];
+    return new Proxy(target, {
+        get(t, prop) {
+            const marker = getMarker(t, prop);
+            if (marker !== undefined) {
+                return marker;
+            }
+            const idx = prop === 'x' || prop === '0'
+                ? 0
+                : prop === 'y' || prop === '1'
+                    ? 1
+                    : prop === 'z' || prop === '2'
+                        ? 2
+                        : prop === 'w' || prop === '3'
+                            ? 3
+                            : -1;
+            if (idx < 0 || idx >= componentCount) {
+                return undefined;
+            }
+            const byteOffset = idx * componentSize;
+            const contiguous = Math.max(0, t[CONTIGUOUS_MARKER] - byteOffset);
+            return scalarNode(baseOffset + byteOffset, contiguous);
+        },
+    });
 }
 function makeArrayProxy(array, target) {
-	const elementType = array.elementType;
-	const elementSize = sizeOf(elementType);
-	const stride = roundUp(elementSize, alignmentOf(elementType));
-	const hasPadding = stride > elementSize;
-	return new Proxy(target, { get(t, prop) {
-		const marker = getMarker(t, prop);
-		if (marker !== void 0) return marker;
-		if (prop === "length") return array.elementCount;
-		if (typeof prop !== "string") return;
-		const index = Number(prop);
-		if (!Number.isInteger(index) || index < 0 || index >= array.elementCount) return;
-		const elementOffset = index * stride;
-		const remainingFromHere = !isContiguous(elementType) ? elementSize + getLongestContiguousPrefix(elementType) : Math.max(0, t[CONTIGUOUS_MARKER] - elementOffset);
-		const childContiguous = hasPadding ? Math.min(remainingFromHere, elementSize) : remainingFromHere;
-		return makeProxy(elementType, t[OFFSET_MARKER] + elementOffset, childContiguous);
-	} });
+    const elementType = array.elementType;
+    const elementSize = sizeOf(elementType);
+    const stride = roundUp(elementSize, alignmentOf(elementType));
+    const hasPadding = stride > elementSize;
+    return new Proxy(target, {
+        get(t, prop) {
+            const marker = getMarker(t, prop);
+            if (marker !== undefined) {
+                return marker;
+            }
+            if (prop === 'length') {
+                return array.elementCount;
+            }
+            if (typeof prop !== 'string') {
+                return undefined;
+            }
+            const index = Number(prop);
+            if (!Number.isInteger(index) || index < 0 || index >= array.elementCount) {
+                return undefined;
+            }
+            const elementOffset = index * stride;
+            const remainingFromHere = !isContiguous(elementType)
+                ? elementSize + getLongestContiguousPrefix(elementType) // it is too much, but we correct it later
+                : Math.max(0, t[CONTIGUOUS_MARKER] - elementOffset);
+            const childContiguous = hasPadding
+                ? Math.min(remainingFromHere, elementSize)
+                : remainingFromHere;
+            return makeProxy(elementType, t[OFFSET_MARKER] + elementOffset, childContiguous);
+        },
+    });
 }
 function makeStructProxy(struct, target) {
-	const offsets = offsetsForProps(struct);
-	const propTypes = struct.propTypes;
-	const propNames = Object.keys(propTypes);
-	const meta = /* @__PURE__ */ new Map();
-	let runStart = 0;
-	for (let i = 0; i < propNames.length; i++) {
-		const name = propNames[i];
-		if (!name) continue;
-		const type = propTypes[name];
-		if (!type) continue;
-		const info = offsets[name];
-		const padding = info.padding ?? 0;
-		const typeContiguous = isContiguous(type);
-		if (!(i === propNames.length - 1 || padding > 0 || !typeContiguous)) continue;
-		const runEnd = info.offset + (typeContiguous ? info.size : getLongestContiguousPrefix(type));
-		for (let j = runStart; j <= i; j++) {
-			const runName = propNames[j];
-			if (!runName) continue;
-			const runInfo = offsets[runName];
-			meta.set(runName, {
-				offset: runInfo.offset,
-				runEnd
-			});
-		}
-		runStart = i + 1;
-	}
-	return new Proxy(target, { get(t, prop) {
-		const marker = getMarker(t, prop);
-		if (marker !== void 0) return marker;
-		if (typeof prop !== "string") return;
-		const m = meta.get(prop);
-		if (!m) return;
-		const remainingFromHere = Math.max(0, t[CONTIGUOUS_MARKER] - m.offset);
-		const localLimit = Math.max(0, m.runEnd - m.offset);
-		const propSchema = propTypes[prop];
-		if (!propSchema) return;
-		return makeProxy(propSchema, t[OFFSET_MARKER] + m.offset, sizeOf(struct) === m.runEnd ? remainingFromHere : localLimit);
-	} });
+    const offsets = offsetsForProps(struct);
+    const propTypes = struct.propTypes;
+    const propNames = Object.keys(propTypes);
+    const meta = new Map();
+    let runStart = 0;
+    for (let i = 0; i < propNames.length; i++) {
+        const name = propNames[i];
+        if (!name) {
+            continue;
+        }
+        const type = propTypes[name];
+        if (!type) {
+            continue;
+        }
+        const info = offsets[name];
+        const padding = info.padding ?? 0;
+        const typeContiguous = isContiguous(type);
+        const isRunEnd = i === propNames.length - 1 || padding > 0 || !typeContiguous;
+        if (!isRunEnd) {
+            continue;
+        }
+        const runEnd = info.offset + (typeContiguous ? info.size : getLongestContiguousPrefix(type));
+        for (let j = runStart; j <= i; j++) {
+            const runName = propNames[j];
+            if (!runName) {
+                continue;
+            }
+            const runInfo = offsets[runName];
+            meta.set(runName, { offset: runInfo.offset, runEnd });
+        }
+        runStart = i + 1;
+    }
+    return new Proxy(target, {
+        get(t, prop) {
+            const marker = getMarker(t, prop);
+            if (marker !== undefined) {
+                return marker;
+            }
+            if (typeof prop !== 'string') {
+                return undefined;
+            }
+            const m = meta.get(prop);
+            if (!m) {
+                return undefined;
+            }
+            const remainingFromHere = Math.max(0, t[CONTIGUOUS_MARKER] - m.offset);
+            const localLimit = Math.max(0, m.runEnd - m.offset);
+            const propSchema = propTypes[prop];
+            if (!propSchema) {
+                return undefined;
+            }
+            return makeProxy(propSchema, t[OFFSET_MARKER] + m.offset, sizeOf(struct) === m.runEnd ? remainingFromHere : localLimit);
+        },
+    });
 }
 function getRootContiguous(schema) {
-	const unwrapped = undecorate(schema);
-	if (isWgslStruct(unwrapped)) {
-		const offsets = offsetsForProps(unwrapped);
-		const propTypes = unwrapped.propTypes;
-		const propNames = Object.keys(propTypes);
-		for (let i = 0; i < propNames.length; i++) {
-			const name = propNames[i];
-			if (!name) continue;
-			const info = offsets[name];
-			const padding = info.padding ?? 0;
-			const runEnd = info.offset + info.size;
-			if (i === propNames.length - 1 || padding > 0) return runEnd;
-		}
-		return 0;
-	}
-	if (isWgslArray(unwrapped)) {
-		const elementType = unwrapped.elementType;
-		const elementSize = sizeOf(elementType);
-		const stride = roundUp(elementSize, alignmentOf(elementType));
-		const totalSize = sizeOf(schema);
-		if (!Number.isFinite(totalSize)) return elementSize;
-		return stride > elementSize ? elementSize : totalSize;
-	}
-	return sizeOf(schema);
+    const unwrapped = undecorate(schema);
+    if (isWgslStruct(unwrapped)) {
+        const offsets = offsetsForProps(unwrapped);
+        const propTypes = unwrapped.propTypes;
+        const propNames = Object.keys(propTypes);
+        for (let i = 0; i < propNames.length; i++) {
+            const name = propNames[i];
+            if (!name) {
+                continue;
+            }
+            const info = offsets[name];
+            const padding = info.padding ?? 0;
+            const runEnd = info.offset + info.size;
+            const isRunEnd = i === propNames.length - 1 || padding > 0;
+            if (isRunEnd) {
+                return runEnd;
+            }
+        }
+        return 0;
+    }
+    if (isWgslArray(unwrapped)) {
+        const elementType = unwrapped.elementType;
+        const elementSize = sizeOf(elementType);
+        const stride = roundUp(elementSize, alignmentOf(elementType));
+        const totalSize = sizeOf(schema);
+        if (!Number.isFinite(totalSize)) {
+            return elementSize;
+        }
+        return stride > elementSize ? elementSize : totalSize;
+    }
+    return sizeOf(schema);
 }
 /**
-* A function that retrieves offset and information for a specific primitive within a data schema.
-* Example usage:
-* ```ts
-* const Boid = d.struct({
-*  position: d.vec3f,
-*  velocity: d.vec3f,
-* });
-* const memLayout = d.memoryLayoutOf(Boid, (b) => b.velocity.y);
-* console.log(memLayout.offset); // Byte offset of velocity.y within Boid (here 20 bytes)
-* console.log(memLayout.contiguous); // Contiguous bytes available from that offset (here 8 bytes)
-* ```
-*
-* @param schema - The data schema to analyze.
-* @param accessor - Optional function that accesses a specific element within the schema. If omitted, uses the root offset (0).
-* @returns An object containing the offset and contiguous byte information.
-*/
-function memoryLayoutOf(schema, accessor) {
-	if (!accessor) return {
-		offset: 0,
-		contiguous: getRootContiguous(schema)
-	};
-	const result = accessor(createOffsetProxy(schema));
-	if (isOffsetProxy(result)) return {
-		offset: result[OFFSET_MARKER],
-		contiguous: result[CONTIGUOUS_MARKER]
-	};
-	throw new Error("memoryLayoutOf: accessor did not return a schema element. Make sure the accessor navigates to a field or element of the schema (e.g. `(s) => s.position.x`).");
+ * A function that retrieves offset and information for a specific primitive within a data schema.
+ * Example usage:
+ * ```ts
+ * const Boid = d.struct({
+ *  position: d.vec3f,
+ *  velocity: d.vec3f,
+ * });
+ * const memLayout = d.memoryLayoutOf(Boid, (b) => b.velocity.y);
+ * console.log(memLayout.offset); // Byte offset of velocity.y within Boid (here 20 bytes)
+ * console.log(memLayout.contiguous); // Contiguous bytes available from that offset (here 8 bytes)
+ * ```
+ *
+ * @param schema - The data schema to analyze.
+ * @param accessor - Optional function that accesses a specific element within the schema. If omitted, uses the root offset (0).
+ * @returns An object containing the offset and contiguous byte information.
+ */
+export function memoryLayoutOf(schema, accessor) {
+    if (!accessor) {
+        return {
+            offset: 0,
+            contiguous: getRootContiguous(schema),
+        };
+    }
+    const proxy = createOffsetProxy(schema);
+    const result = accessor(proxy);
+    if (isOffsetProxy(result)) {
+        return {
+            offset: result[OFFSET_MARKER],
+            contiguous: result[CONTIGUOUS_MARKER],
+        };
+    }
+    throw new Error('memoryLayoutOf: accessor did not return a schema element. Make sure the accessor navigates to a field or element of the schema (e.g. `(s) => s.position.x`).');
 }
-
-//#endregion
-export { memoryLayoutOf };

package/data/offsets.d.ts

@@ -0,0 +1,8 @@
+import { type Unstruct } from './dataTypes.ts';
+import type { WgslStruct } from './wgslTypes.ts';
+export interface OffsetInfo {
+    offset: number;
+    size: number;
+    padding?: number | undefined;
+}
+export declare function offsetsForProps<T extends WgslStruct | Unstruct>(struct: T): Record<keyof T['propTypes'], OffsetInfo>;

package/data/offsets.js

@@ -1,36 +1,36 @@
-import { isUnstruct } from "./dataTypes.js";
-import { alignmentOf, customAlignmentOf } from "./alignmentOf.js";
+import { Measurer } from 'typed-binary';
 import { roundUp } from "../mathUtils.js";
+import alignIO from "./alignIO.js";
+import { alignmentOf, customAlignmentOf } from "./alignmentOf.js";
+import { isUnstruct } from "./dataTypes.js";
 import { sizeOf } from "./sizeOf.js";
-import alignIO_default from "./alignIO.js";
-import { Measurer } from "typed-binary";
-
-//#region src/data/offsets.ts
-const cachedOffsets = /* @__PURE__ */ new WeakMap();
-function offsetsForProps(struct) {
-	const cached = cachedOffsets.get(struct);
-	if (cached) return cached;
-	const measurer = new Measurer();
-	const offsets = {};
-	let lastEntry;
-	for (const key in struct.propTypes) {
-		const prop = struct.propTypes[key];
-		if (prop === void 0) throw new Error(`Property ${key} is undefined in struct`);
-		const beforeAlignment = measurer.size;
-		alignIO_default(measurer, isUnstruct(struct) ? customAlignmentOf(prop) : alignmentOf(prop));
-		if (lastEntry) lastEntry.padding = measurer.size - beforeAlignment;
-		const propSize = sizeOf(prop);
-		offsets[key] = {
-			offset: measurer.size,
-			size: propSize
-		};
-		lastEntry = offsets[key];
-		measurer.add(propSize);
-	}
-	if (lastEntry) lastEntry.padding = roundUp(sizeOf(struct), alignmentOf(struct)) - measurer.size;
-	cachedOffsets.set(struct, offsets);
-	return offsets;
+const cachedOffsets = new WeakMap();
+export function offsetsForProps(struct) {
+    const cached = cachedOffsets.get(struct);
+    if (cached) {
+        return cached;
+    }
+    const measurer = new Measurer();
+    const offsets = {};
+    let lastEntry;
+    for (const key in struct.propTypes) {
+        const prop = struct.propTypes[key];
+        if (prop === undefined) {
+            throw new Error(`Property ${key} is undefined in struct`);
+        }
+        const beforeAlignment = measurer.size;
+        alignIO(measurer, isUnstruct(struct) ? customAlignmentOf(prop) : alignmentOf(prop));
+        if (lastEntry) {
+            lastEntry.padding = measurer.size - beforeAlignment;
+        }
+        const propSize = sizeOf(prop);
+        offsets[key] = { offset: measurer.size, size: propSize };
+        lastEntry = offsets[key];
+        measurer.add(propSize);
+    }
+    if (lastEntry) {
+        lastEntry.padding = roundUp(sizeOf(struct), alignmentOf(struct)) - measurer.size;
+    }
+    cachedOffsets.set(struct, offsets);
+    return offsets;
 }
-
-//#endregion
-export { offsetsForProps };

package/data/partialIO.d.ts

@@ -1,8 +1,13 @@
-import { BaseData } from "./wgslTypes.js";
-import { InferPatch } from "../shared/repr.js";
-
-//#region src/data/partialIO.d.ts
-
-declare function patchArrayBuffer<T extends BaseData>(buffer: ArrayBuffer, schema: T, data: InferPatch<T>): void;
-//#endregion
-export { patchArrayBuffer };
+import type * as wgsl from './wgslTypes.ts';
+import { type BaseData } from './wgslTypes.ts';
+import type { InferPatch } from '../shared/repr.ts';
+export interface WriteInstruction {
+    data: Uint8Array<ArrayBuffer>;
+    gpuOffset: number;
+}
+/**
+ * Converts `{idx, value}[]` sparse arrays into `Record<number, T>` format.
+ */
+export declare function convertPartialToPatch(schema: wgsl.BaseData, data: unknown): unknown;
+export declare function getPatchInstructions<TData extends wgsl.BaseData>(schema: TData, data: unknown, targetBuffer?: ArrayBuffer): WriteInstruction[];
+export declare function patchArrayBuffer<T extends BaseData>(buffer: ArrayBuffer, schema: T, data: InferPatch<T>): void;