typegpu 0.11.9 → 0.12.1

package/data/dataTypes.d.ts

@@ -1,15 +1,13 @@
-import { TgpuNamable } from "../shared/meta.js";
-import { $gpuRepr, $inRepr, $invalidSchemaReason, $memIdent, $repr, $reprPartial, $reprPatch, $validVertexSchema } from "../shared/symbols.js";
-import { Prettify } from "../shared/utilityTypes.js";
-import "./sampler.js";
-import "./snippet.js";
-import { PackedData } from "./vertexFormatData.js";
-import { AnyWgslData, BaseData, TypedArrayFor } from "./wgslTypes.js";
-import "./texture.js";
-import { Infer, InferGPURecord, InferInput, InferInputRecord, InferPartial, InferPartialRecord, InferPatch, InferPatchRecord, InferRecord, IsValidVertexSchema, MemIdentityRecord } from "../shared/repr.js";
-
-//#region src/data/dataTypes.d.ts
-
+import { type TgpuNamable } from '../shared/meta.ts';
+import type { Infer, InferGPURecord, InferInput, InferInputRecord, InferPatch, InferPatchRecord, InferPartial, InferPartialRecord, InferRecord, IsValidVertexSchema, MemIdentityRecord } from '../shared/repr.ts';
+import type { $gpuRepr, $inRepr, $invalidSchemaReason, $memIdent, $repr, $reprPartial, $reprPatch, $validVertexSchema } from '../shared/symbols.ts';
+import type { Prettify } from '../shared/utilityTypes.ts';
+import type { WgslExternalTexture, WgslStorageTexture, WgslTexture } from './texture.ts';
+import type { Snippet } from './snippet.ts';
+import type { PackedData } from './vertexFormatData.ts';
+import * as wgsl from './wgslTypes.ts';
+import type { WgslComparisonSampler, WgslSampler } from './sampler.ts';
+import type { BaseData } from './wgslTypes.ts';
 /**
  * Array schema constructed via `d.disarrayOf` function.
  *
@@ -18,21 +16,21 @@ import { Infer, InferGPURecord, InferInput, InferInputRecord, InferPartial, Infe
  * unless they are explicitly decorated with the custom align attribute
  * via `d.align` function.
  */
-interface Disarray<out TElement extends BaseData = BaseData> extends BaseData {
-  <T extends TElement>(elements: Infer<T>[]): Infer<T>[];
-  (): Infer<TElement>[];
-  readonly type: 'disarray';
-  readonly elementCount: number;
-  readonly elementType: TElement;
-  readonly [$repr]: Infer<TElement>[];
-  readonly [$inRepr]: readonly InferInput<TElement>[] | TypedArrayFor<TElement>;
-  readonly [$reprPartial]: {
-    idx: number;
-    value: InferPartial<TElement>;
-  }[] | undefined;
-  readonly [$reprPatch]: Record<number, InferPatch<TElement>> | InferInput<TElement>[] | TypedArrayFor<TElement> | undefined;
-  readonly [$validVertexSchema]: IsValidVertexSchema<TElement>;
-  readonly [$invalidSchemaReason]: 'Disarrays are not host-shareable, use arrays instead';
+export interface Disarray<out TElement extends wgsl.BaseData = wgsl.BaseData> extends wgsl.BaseData {
+    <T extends TElement>(elements: Infer<T>[]): Infer<T>[];
+    (): Infer<TElement>[];
+    readonly type: 'disarray';
+    readonly elementCount: number;
+    readonly elementType: TElement;
+    readonly [$repr]: Infer<TElement>[];
+    readonly [$inRepr]: readonly InferInput<TElement>[] | wgsl.TypedArrayFor<TElement>;
+    readonly [$reprPartial]: {
+        idx: number;
+        value: InferPartial<TElement>;
+    }[] | undefined;
+    readonly [$reprPatch]: Record<number, InferPatch<TElement>> | InferInput<TElement>[] | wgsl.TypedArrayFor<TElement> | undefined;
+    readonly [$validVertexSchema]: IsValidVertexSchema<TElement>;
+    readonly [$invalidSchemaReason]: 'Disarrays are not host-shareable, use arrays instead';
 }
 /**
  * Struct schema constructed via `d.unstruct` function.
@@ -42,46 +40,59 @@ interface Disarray<out TElement extends BaseData = BaseData> extends BaseData {
  * unless they are explicitly decorated with the custom align attribute
  * via `d.align` function.
  */
-interface Unstruct<out TProps extends Record<string, BaseData> = Record<string, BaseData>> extends BaseData, TgpuNamable {
-  (props: Prettify<InferRecord<TProps>>): Prettify<InferRecord<TProps>>;
-  (): Prettify<InferRecord<TProps>>;
-  readonly type: 'unstruct';
-  readonly propTypes: TProps;
-  readonly [$repr]: Prettify<InferRecord<TProps>>;
-  readonly [$inRepr]: Prettify<InferInputRecord<TProps>>;
-  readonly [$gpuRepr]: Prettify<InferGPURecord<TProps>>;
-  readonly [$memIdent]: Unstruct<Prettify<MemIdentityRecord<TProps>>>;
-  readonly [$reprPartial]: Prettify<Partial<InferPartialRecord<TProps>>> | undefined;
-  readonly [$reprPatch]: Prettify<Partial<InferPatchRecord<TProps>>> | undefined;
-  readonly [$validVertexSchema]: { [K in keyof TProps]: IsValidVertexSchema<TProps[K]> }[keyof TProps] extends true ? true : false;
-  readonly [$invalidSchemaReason]: 'Unstructs are not host-shareable, use structs instead';
+export interface Unstruct<out TProps extends Record<string, wgsl.BaseData> = Record<string, wgsl.BaseData>> extends wgsl.BaseData, TgpuNamable {
+    (props: Prettify<InferRecord<TProps>>): Prettify<InferRecord<TProps>>;
+    (): Prettify<InferRecord<TProps>>;
+    readonly type: 'unstruct';
+    readonly propTypes: TProps;
+    readonly [$repr]: Prettify<InferRecord<TProps>>;
+    readonly [$inRepr]: Prettify<InferInputRecord<TProps>>;
+    readonly [$gpuRepr]: Prettify<InferGPURecord<TProps>>;
+    readonly [$memIdent]: Unstruct<Prettify<MemIdentityRecord<TProps>>>;
+    readonly [$reprPartial]: Prettify<Partial<InferPartialRecord<TProps>>> | undefined;
+    readonly [$reprPatch]: Prettify<Partial<InferPatchRecord<TProps>>> | undefined;
+    readonly [$validVertexSchema]: {
+        [K in keyof TProps]: IsValidVertexSchema<TProps[K]>;
+    }[keyof TProps] extends true ? true : false;
+    readonly [$invalidSchemaReason]: 'Unstructs are not host-shareable, use structs instead';
 }
-interface LooseDecorated<out TInner$1 extends BaseData = BaseData, out TAttribs extends unknown[] = unknown[]> extends BaseData {
-  readonly type: 'loose-decorated';
-  readonly inner: TInner$1;
-  readonly attribs: TAttribs;
-  readonly [$repr]: Infer<TInner$1>;
-  readonly [$invalidSchemaReason]: 'Loosely decorated schemas are not host-shareable';
-  readonly [$validVertexSchema]: IsValidVertexSchema<TInner$1>;
+/** @deprecated Just use `Unstruct` without any type parameters */
+export type AnyUnstruct = Unstruct;
+export interface LooseDecorated<out TInner extends wgsl.BaseData = wgsl.BaseData, out TAttribs extends unknown[] = unknown[]> extends wgsl.BaseData {
+    readonly type: 'loose-decorated';
+    readonly inner: TInner;
+    readonly attribs: TAttribs;
+    readonly [$repr]: Infer<TInner>;
+    readonly [$invalidSchemaReason]: 'Loosely decorated schemas are not host-shareable';
+    readonly [$validVertexSchema]: IsValidVertexSchema<TInner>;
 }
 /**
  * Type utility to extract the inner type from decorated types.
  */
-type Undecorate<T> = T extends {
-  readonly type: 'decorated' | 'loose-decorated';
-  readonly inner: infer TInner;
+export type Undecorate<T> = T extends {
+    readonly type: 'decorated' | 'loose-decorated';
+    readonly inner: infer TInner;
 } ? TInner : T;
 /**
  * Type utility to undecorate all values in a record.
  */
-type UndecorateRecord<T extends Record<string, unknown>> = { [Key in keyof T]: Undecorate<T[Key]> };
+export type UndecorateRecord<T extends Record<string, unknown>> = {
+    [Key in keyof T]: Undecorate<T[Key]>;
+};
+/**
+ * Runtime function to extract the inner data type from decorated types.
+ * If the data is not decorated, returns the data as-is.
+ */
+export declare function undecorate(data: BaseData): BaseData;
+export declare function unptr(data: BaseData): BaseData;
+export declare function unptr(data: BaseData | UnknownData): BaseData | UnknownData;
 declare const looseTypeLiterals: readonly ["unstruct", "disarray", "loose-decorated", "uint8", "uint8x2", "uint8x4", "sint8", "sint8x2", "sint8x4", "unorm8", "unorm8x2", "unorm8x4", "snorm8", "snorm8x2", "snorm8x4", "uint16", "uint16x2", "uint16x4", "sint16", "sint16x2", "sint16x4", "unorm16", "unorm16x2", "unorm16x4", "snorm16", "snorm16x2", "snorm16x4", "float16", "float16x2", "float16x4", "float32", "float32x2", "float32x3", "float32x4", "uint32", "uint32x2", "uint32x3", "uint32x4", "sint32", "sint32x2", "sint32x3", "sint32x4", "unorm10-10-10-2", "unorm8x4-bgra"];
-type LooseTypeLiteral = (typeof looseTypeLiterals)[number];
-type IsLooseData<T> = T extends {
-  readonly type: LooseTypeLiteral;
+export type LooseTypeLiteral = (typeof looseTypeLiterals)[number];
+export type IsLooseData<T> = T extends {
+    readonly type: LooseTypeLiteral;
 } ? true : false;
-type AnyLooseData = Disarray | Unstruct | LooseDecorated | PackedData;
-declare function isLooseData(data: unknown): data is AnyLooseData;
+export type AnyLooseData = Disarray | Unstruct | LooseDecorated | PackedData;
+export declare function isLooseData(data: unknown): data is AnyLooseData;
 /**
  * Checks whether the passed in value is a disarray schema,
  * as opposed to, e.g., a regular array schema.
@@ -95,7 +106,7 @@ declare function isLooseData(data: unknown): data is AnyLooseData;
  * isDisarray(d.disarrayOf(d.u32, 4)) // true
  * isDisarray(d.vec3f) // false
  */
-declare function isDisarray(schema: unknown): schema is Disarray;
+export declare function isDisarray(schema: unknown): schema is Disarray;
 /**
  * Checks whether passed in value is a unstruct schema,
  * as opposed to, e.g., a struct schema.
@@ -109,11 +120,18 @@ declare function isDisarray(schema: unknown): schema is Disarray;
  * isUnstruct(d.unstruct({ a: d.u32 })) // true
  * isUnstruct(d.vec3f) // false
  */
-declare function isUnstruct(schema: unknown): schema is Unstruct;
-declare function isLooseDecorated(value: unknown): value is LooseDecorated;
-declare function isData(value: unknown): value is AnyData;
-type AnyData = AnyWgslData | AnyLooseData;
-declare const UnknownData: unique symbol;
-type UnknownData = typeof UnknownData;
-//#endregion
-export { AnyData, AnyLooseData, Disarray, IsLooseData, LooseDecorated, Undecorate, UndecorateRecord, UnknownData, Unstruct, isData, isDisarray, isLooseData, isLooseDecorated, isUnstruct };
+export declare function isUnstruct(schema: unknown): schema is Unstruct;
+export declare function isLooseDecorated(value: unknown): value is LooseDecorated;
+export declare function getCustomAlignment(data: wgsl.BaseData): number | undefined;
+export declare function getCustomSize(data: wgsl.BaseData): number | undefined;
+export declare function getCustomLocation(data: wgsl.BaseData): number | undefined;
+export declare function isData(value: unknown): value is AnyData;
+export type AnyData = wgsl.AnyWgslData | AnyLooseData;
+export type AnyConcreteData = Exclude<AnyData, wgsl.AbstractInt | wgsl.AbstractFloat | wgsl.Void | WgslTexture | WgslStorageTexture | WgslExternalTexture | WgslSampler | WgslComparisonSampler>;
+export declare const UnknownData: unique symbol;
+export type UnknownData = typeof UnknownData;
+export declare class MatrixColumnsAccess {
+    readonly matrix: Snippet;
+    constructor(matrix: Snippet);
+}
+export {};

package/data/dataTypes.js

@@ -1,83 +1,81 @@
+import {} from "../shared/meta.js";
 import { isMarkedInternal } from "../shared/symbols.js";
-import { isAlignAttrib, isDecorated, isLocationAttrib, isPtr, isSizeAttrib, isWgslData } from "./wgslTypes.js";
 import { vertexFormats } from "../shared/vertexFormat.js";
-
-//#region src/data/dataTypes.ts
+import * as wgsl from "./wgslTypes.js";
 /**
-* Runtime function to extract the inner data type from decorated types.
-* If the data is not decorated, returns the data as-is.
-*/
-function undecorate(data) {
-	if (isDecorated(data) || isLooseDecorated(data)) return data.inner;
-	return data;
+ * Runtime function to extract the inner data type from decorated types.
+ * If the data is not decorated, returns the data as-is.
+ */
+export function undecorate(data) {
+    if (wgsl.isDecorated(data) || isLooseDecorated(data)) {
+        return data.inner;
+    }
+    return data;
 }
-function unptr(data) {
-	if (isPtr(data)) return data.inner;
-	return data;
+export function unptr(data) {
+    if (wgsl.isPtr(data)) {
+        return data.inner;
+    }
+    return data;
 }
-const looseTypeLiterals = [
-	"unstruct",
-	"disarray",
-	"loose-decorated",
-	...vertexFormats
-];
-function isLooseData(data) {
-	return isMarkedInternal(data) && looseTypeLiterals.includes(data?.type);
+const looseTypeLiterals = ['unstruct', 'disarray', 'loose-decorated', ...vertexFormats];
+export function isLooseData(data) {
+    return isMarkedInternal(data) && looseTypeLiterals.includes(data?.type);
 }
 /**
-* Checks whether the passed in value is a disarray schema,
-* as opposed to, e.g., a regular array schema.
-*
-* Array schemas can be used to describe uniform and storage buffers,
-* whereas disarray schemas cannot. Disarrays are useful for
-* defining vertex buffers instead.
-*
-* @example
-* isDisarray(d.arrayOf(d.u32, 4)) // false
-* isDisarray(d.disarrayOf(d.u32, 4)) // true
-* isDisarray(d.vec3f) // false
-*/
-function isDisarray(schema) {
-	return isMarkedInternal(schema) && schema?.type === "disarray";
+ * Checks whether the passed in value is a disarray schema,
+ * as opposed to, e.g., a regular array schema.
+ *
+ * Array schemas can be used to describe uniform and storage buffers,
+ * whereas disarray schemas cannot. Disarrays are useful for
+ * defining vertex buffers instead.
+ *
+ * @example
+ * isDisarray(d.arrayOf(d.u32, 4)) // false
+ * isDisarray(d.disarrayOf(d.u32, 4)) // true
+ * isDisarray(d.vec3f) // false
+ */
+export function isDisarray(schema) {
+    return isMarkedInternal(schema) && schema?.type === 'disarray';
 }
 /**
-* Checks whether passed in value is a unstruct schema,
-* as opposed to, e.g., a struct schema.
-*
-* Struct schemas can be used to describe uniform and storage buffers,
-* whereas unstruct schemas cannot. Unstructs are useful for
-* defining vertex buffers instead.
-*
-* @example
-* isUnstruct(d.struct({ a: d.u32 })) // false
-* isUnstruct(d.unstruct({ a: d.u32 })) // true
-* isUnstruct(d.vec3f) // false
-*/
-function isUnstruct(schema) {
-	return isMarkedInternal(schema) && schema?.type === "unstruct";
+ * Checks whether passed in value is a unstruct schema,
+ * as opposed to, e.g., a struct schema.
+ *
+ * Struct schemas can be used to describe uniform and storage buffers,
+ * whereas unstruct schemas cannot. Unstructs are useful for
+ * defining vertex buffers instead.
+ *
+ * @example
+ * isUnstruct(d.struct({ a: d.u32 })) // false
+ * isUnstruct(d.unstruct({ a: d.u32 })) // true
+ * isUnstruct(d.vec3f) // false
+ */
+export function isUnstruct(schema) {
+    return isMarkedInternal(schema) && schema?.type === 'unstruct';
 }
-function isLooseDecorated(value) {
-	return isMarkedInternal(value) && value?.type === "loose-decorated";
+export function isLooseDecorated(value) {
+    return isMarkedInternal(value) && value?.type === 'loose-decorated';
 }
-function getCustomAlignment(data) {
-	return data.attribs?.find(isAlignAttrib)?.params[0];
+export function getCustomAlignment(data) {
+    return data.attribs?.find(wgsl.isAlignAttrib)
+        ?.params[0];
 }
-function getCustomSize(data) {
-	return data.attribs?.find(isSizeAttrib)?.params[0];
+export function getCustomSize(data) {
+    return data.attribs?.find(wgsl.isSizeAttrib)
+        ?.params[0];
 }
-function getCustomLocation(data) {
-	return data.attribs?.find(isLocationAttrib)?.params[0];
+export function getCustomLocation(data) {
+    return data.attribs?.find(wgsl.isLocationAttrib)
+        ?.params[0];
 }
-function isData(value) {
-	return isWgslData(value) || isLooseData(value);
+export function isData(value) {
+    return wgsl.isWgslData(value) || isLooseData(value);
+}
+export const UnknownData = Symbol('UNKNOWN');
+export class MatrixColumnsAccess {
+    matrix;
+    constructor(matrix) {
+        this.matrix = matrix;
+    }
 }
-const UnknownData = Symbol("UNKNOWN");
-var MatrixColumnsAccess = class {
-	matrix;
-	constructor(matrix) {
-		this.matrix = matrix;
-	}
-};
-
-//#endregion
-export { MatrixColumnsAccess, UnknownData, getCustomAlignment, getCustomLocation, getCustomSize, isData, isDisarray, isLooseData, isLooseDecorated, isUnstruct, undecorate, unptr };

package/data/deepEqual.d.ts

@@ -1,7 +1,4 @@
-import { AnyData } from "./dataTypes.js";
-
-//#region src/data/deepEqual.d.ts
-
+import type { AnyData } from './dataTypes.ts';
 /**
  * Performs a deep comparison of two TypeGPU data schemas.
  *
@@ -21,6 +18,4 @@ import { AnyData } from "./dataTypes.js";
  * console.log(deepEqual(schema1, schema3)); // false
  * ```
  */
-declare function deepEqual(a: AnyData, b: AnyData): boolean;
-//#endregion
-export { deepEqual };
+export declare function deepEqual(a: AnyData, b: AnyData): boolean;

package/data/deepEqual.js

@@ -1,58 +1,83 @@
-import { isAtomic, isDecorated, isPtr, isWgslArray, isWgslStruct } from "./wgslTypes.js";
 import { isDisarray, isLooseDecorated, isUnstruct } from "./dataTypes.js";
-
-//#region src/data/deepEqual.ts
+import { isAtomic, isDecorated, isPtr, isWgslArray, isWgslStruct } from "./wgslTypes.js";
 /**
-* Performs a deep comparison of two TypeGPU data schemas.
-*
-* @param a The first data schema to compare.
-* @param b The second data schema to compare.
-* @returns `true` if the schemas are deeply equal, `false` otherwise.
-*
-* @example
-* ```ts
-* import { vec3f, struct, deepEqual } from 'typegpu/data';
-*
-* const schema1 = struct({ a: vec3f });
-* const schema2 = struct({ a: vec3f });
-* const schema3 = struct({ b: vec3f });
-*
-* console.log(deepEqual(schema1, schema2)); // true
-* console.log(deepEqual(schema1, schema3)); // false
-* ```
-*/
-function deepEqual(a, b) {
-	if (a === b) return true;
-	if (a.type !== b.type) return false;
-	if (isWgslStruct(a) && isWgslStruct(b) || isUnstruct(a) && isUnstruct(b)) {
-		const aProps = a.propTypes;
-		const bProps = b.propTypes;
-		const aKeys = Object.keys(aProps);
-		const bKeys = Object.keys(bProps);
-		if (aKeys.length !== bKeys.length) return false;
-		for (let i = 0; i < aKeys.length; i++) {
-			const keyA = aKeys[i];
-			const keyB = bKeys[i];
-			if (keyA !== keyB || !keyA || !keyB || !deepEqual(aProps[keyA], bProps[keyB])) return false;
-		}
-		return true;
-	}
-	if (isWgslArray(a) && isWgslArray(b) || isDisarray(a) && isDisarray(b)) return a.elementCount === b.elementCount && deepEqual(a.elementType, b.elementType);
-	if (isPtr(a) && isPtr(b)) return a.addressSpace === b.addressSpace && a.access === b.access && deepEqual(a.inner, b.inner);
-	if (isAtomic(a) && isAtomic(b)) return deepEqual(a.inner, b.inner);
-	if (isDecorated(a) && isDecorated(b) || isLooseDecorated(a) && isLooseDecorated(b)) {
-		if (!deepEqual(a.inner, b.inner)) return false;
-		if (a.attribs.length !== b.attribs.length) return false;
-		const getAttrKey = (attr) => {
-			const anyAttr = attr;
-			return `${anyAttr.type}(${(anyAttr.params ?? []).join(",")})`;
-		};
-		const attrsA = a.attribs.map(getAttrKey);
-		const attrsB = b.attribs.map(getAttrKey);
-		for (let i = 0; i < attrsA.length; i++) if (attrsA[i] !== attrsB[i]) return false;
-	}
-	return true;
+ * Performs a deep comparison of two TypeGPU data schemas.
+ *
+ * @param a The first data schema to compare.
+ * @param b The second data schema to compare.
+ * @returns `true` if the schemas are deeply equal, `false` otherwise.
+ *
+ * @example
+ * ```ts
+ * import { vec3f, struct, deepEqual } from 'typegpu/data';
+ *
+ * const schema1 = struct({ a: vec3f });
+ * const schema2 = struct({ a: vec3f });
+ * const schema3 = struct({ b: vec3f });
+ *
+ * console.log(deepEqual(schema1, schema2)); // true
+ * console.log(deepEqual(schema1, schema3)); // false
+ * ```
+ */
+export function deepEqual(a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (a.type !== b.type) {
+        return false;
+    }
+    if ((isWgslStruct(a) && isWgslStruct(b)) || (isUnstruct(a) && isUnstruct(b))) {
+        const aProps = a.propTypes;
+        const bProps = b.propTypes;
+        const aKeys = Object.keys(aProps);
+        const bKeys = Object.keys(bProps);
+        if (aKeys.length !== bKeys.length) {
+            return false;
+        }
+        for (let i = 0; i < aKeys.length; i++) {
+            const keyA = aKeys[i];
+            const keyB = bKeys[i];
+            if (keyA !== keyB ||
+                !keyA ||
+                !keyB ||
+                !deepEqual(aProps[keyA], bProps[keyB])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if ((isWgslArray(a) && isWgslArray(b)) || (isDisarray(a) && isDisarray(b))) {
+        return (a.elementCount === b.elementCount &&
+            deepEqual(a.elementType, b.elementType));
+    }
+    if (isPtr(a) && isPtr(b)) {
+        return (a.addressSpace === b.addressSpace &&
+            a.access === b.access &&
+            deepEqual(a.inner, b.inner));
+    }
+    if (isAtomic(a) && isAtomic(b)) {
+        return deepEqual(a.inner, b.inner);
+    }
+    if ((isDecorated(a) && isDecorated(b)) || (isLooseDecorated(a) && isLooseDecorated(b))) {
+        if (!deepEqual(a.inner, b.inner)) {
+            return false;
+        }
+        if (a.attribs.length !== b.attribs.length) {
+            return false;
+        }
+        // Create comparable string representations for each attribute
+        const getAttrKey = (attr) => {
+            const anyAttr = attr;
+            return `${anyAttr.type}(${(anyAttr.params ?? []).join(',')})`;
+        };
+        const attrsA = a.attribs.map(getAttrKey);
+        const attrsB = b.attribs.map(getAttrKey);
+        for (let i = 0; i < attrsA.length; i++) {
+            if (attrsA[i] !== attrsB[i]) {
+                return false;
+            }
+        }
+    }
+    // All other types have been checked for equality at the start
+    return true;
 }
-
-//#endregion
-export { deepEqual };

package/data/disarray.d.ts

@@ -1,11 +1,7 @@
-import { AnyData, Disarray } from "./dataTypes.js";
-import { TgpuComptime } from "../core/function/comptime.js";
-import "../indexNamedExports.js";
-
-//#region src/data/disarray.d.ts
+import type { AnyData, Disarray } from './dataTypes.ts';
 interface DisarrayConstructor {
-  <TElement extends AnyData>(elementType: TElement): (elementCount: number) => Disarray<TElement>;
-  <TElement extends AnyData>(elementType: TElement, elementCount: number): Disarray<TElement>;
+    <TElement extends AnyData>(elementType: TElement): (elementCount: number) => Disarray<TElement>;
+    <TElement extends AnyData>(elementType: TElement, elementCount: number): Disarray<TElement>;
 }
 /**
  * Creates an array schema that can be used to construct vertex buffers.
@@ -29,6 +25,6 @@ interface DisarrayConstructor {
  * @param elementType The type of elements in the array.
  * @param elementCount The number of elements in the array.
  */
-declare const disarrayOf: TgpuComptime<DisarrayConstructor>;
-//#endregion
-export { disarrayOf };
+export declare const disarrayOf: import("../indexNamedExports.ts").TgpuComptime<DisarrayConstructor>;
+export declare function cpu_disarrayOf<TElement extends AnyData>(elementType: TElement, elementCount: number): Disarray<TElement>;
+export {};

package/data/disarray.js

@@ -1,52 +1,58 @@
+import { comptime } from "../core/function/comptime.js";
 import { $internal } from "../shared/symbols.js";
 import { schemaCallWrapper } from "./schemaCallWrapper.js";
-import { comptime } from "../core/function/comptime.js";
-
-//#region src/data/disarray.ts
 /**
-* Creates an array schema that can be used to construct vertex buffers.
-* Describes arrays with fixed-size length, storing elements of the same type.
-*
-* Elements in the schema are not aligned in respect to their `byteAlignment`,
-* unless they are explicitly decorated with the custom align attribute
-* via `d.align` function.
-*
-* @example
-* const disarray = d.disarrayOf(d.vec3f, 3); // packed array of vec3f
-*
-* @example
-* const disarray = d.disarrayOf(d.align(16, d.vec3f), 3);
-*
-* If `elementCount` is not specified, a partially applied function is returned.
-* @example
-* const disarray = d.disarrayOf(d.vec3f);
-* //    ^? (n: number) => Disarray<d.Vec3f>
-*
-* @param elementType The type of elements in the array.
-* @param elementCount The number of elements in the array.
-*/
-const disarrayOf = comptime(((elementType, elementCount) => {
-	if (elementCount === void 0) return (count) => cpu_disarrayOf(elementType, count);
-	return cpu_disarrayOf(elementType, elementCount);
-})).$name("disarrayOf");
-function cpu_disarrayOf(elementType, elementCount) {
-	const disarraySchema = (elements) => {
-		if (elements && elements.length !== elementCount) throw new Error(`Disarray schema of ${elementCount} elements of type ${elementType.type} called with ${elements.length} argument(s).`);
-		return Array.from({ length: elementCount }, (_, i) => schemaCallWrapper(elementType, elements?.[i]));
-	};
-	Object.setPrototypeOf(disarraySchema, DisarrayImpl);
-	disarraySchema.elementType = elementType;
-	if (!Number.isInteger(elementCount) || elementCount < 0) throw new Error(`Cannot create disarray schema with invalid element count: ${elementCount}.`);
-	disarraySchema.elementCount = elementCount;
-	return disarraySchema;
+ * Creates an array schema that can be used to construct vertex buffers.
+ * Describes arrays with fixed-size length, storing elements of the same type.
+ *
+ * Elements in the schema are not aligned in respect to their `byteAlignment`,
+ * unless they are explicitly decorated with the custom align attribute
+ * via `d.align` function.
+ *
+ * @example
+ * const disarray = d.disarrayOf(d.vec3f, 3); // packed array of vec3f
+ *
+ * @example
+ * const disarray = d.disarrayOf(d.align(16, d.vec3f), 3);
+ *
+ * If `elementCount` is not specified, a partially applied function is returned.
+ * @example
+ * const disarray = d.disarrayOf(d.vec3f);
+ * //    ^? (n: number) => Disarray<d.Vec3f>
+ *
+ * @param elementType The type of elements in the array.
+ * @param elementCount The number of elements in the array.
+ */
+export const disarrayOf = comptime(((elementType, elementCount) => {
+    if (elementCount === undefined) {
+        return (count) => cpu_disarrayOf(elementType, count);
+    }
+    return cpu_disarrayOf(elementType, elementCount);
+})).$name('disarrayOf');
+export function cpu_disarrayOf(elementType, elementCount) {
+    // In the schema call, create and return a deep copy
+    // by wrapping all the values in `elementType` schema calls.
+    const disarraySchema = (elements) => {
+        if (elements && elements.length !== elementCount) {
+            throw new Error(`Disarray schema of ${elementCount} elements of type ${elementType.type} called with ${elements.length} argument(s).`);
+        }
+        return Array.from({ length: elementCount }, (_, i) => schemaCallWrapper(elementType, elements?.[i]));
+    };
+    Object.setPrototypeOf(disarraySchema, DisarrayImpl);
+    disarraySchema.elementType = elementType;
+    if (!Number.isInteger(elementCount) || elementCount < 0) {
+        throw new Error(`Cannot create disarray schema with invalid element count: ${elementCount}.`);
+    }
+    disarraySchema.elementCount = elementCount;
+    return disarraySchema;
 }
+// --------------
+// Implementation
+// --------------
 const DisarrayImpl = {
-	[$internal]: true,
-	type: "disarray",
-	toString() {
-		return `disarrayOf(${this.elementType}, ${this.elementCount})`;
-	}
+    [$internal]: true,
+    type: 'disarray',
+    toString() {
+        return `disarrayOf(${this.elementType}, ${this.elementCount})`;
+    },
 };
-
-//#endregion
-export { disarrayOf };

package/data/float16Conversion.d.ts

@@ -0,0 +1,4 @@
+import type { ISerialInput } from 'typed-binary';
+import type { ISerialOutput } from 'typed-binary';
+export declare function writeFloat16(output: ISerialOutput, value: number): void;
+export declare function readFloat16(input: ISerialInput): number;

package/data/float16Conversion.js

@@ -0,0 +1,7 @@
+import { fromHalfBits, toHalfBits } from "./numeric.js";
+export function writeFloat16(output, value) {
+    output.writeUint16(toHalfBits(value));
+}
+export function readFloat16(input) {
+    return fromHalfBits(input.readUint16());
+}