@adobe/data 0.1.3 → 0.2.1

package/src/typed-buffer/structs/create-read-struct.ts

@@ -0,0 +1,77 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+import { memoizeFactory } from "../../internal/function/memoize-factory.js";
+import type { ReadStruct } from "./read-struct.js";
+import type { StructLayout } from "./struct-layout.js";
+import { getFieldOffset } from "./get-field-offset.js";
+
+type ViewType = 'f32' | 'i32' | 'u32';
+type ViewTypes = Record<ViewType, boolean>;
+
+const generateStructBody = (
+    layout: StructLayout,
+    parentOffset = '',
+    indent = '    ',
+    usedViews: ViewTypes = { f32: false, i32: false, u32: false }
+): [string, ViewTypes] => {
+    if (typeof layout === 'string') {
+        usedViews[layout as ViewType] = true;
+        return [`__${layout}[${parentOffset}]`, usedViews];
+    }
+
+    const entries = layout.type === 'array' ?
+        Object.entries(layout.fields).sort((a, b) => +a[0] - +b[0]) :
+        Object.entries(layout.fields);
+
+    let body = '';
+    for (const [name, field] of entries) {
+        const fieldOffset = getFieldOffset(field, parentOffset);
+        const [value] = typeof field.type === 'string' ?
+            [(`__${field.type}[${fieldOffset}]`), usedViews[field.type as ViewType] = true] :
+            generateStructBody(field.type, fieldOffset, indent + '    ', usedViews);
+
+        if (layout.type === 'array') {
+            body += `\n${indent}${value},`;
+        } else {
+            body += `\n${indent}${name}: ${value},`;
+        }
+    }
+    return [layout.type === 'array' ? 
+        `[${body}\n${indent.slice(4)}]` : 
+        `{${body}\n${indent.slice(4)}}`,
+        usedViews
+    ];
+};
+
+
+export const createReadStruct = memoizeFactory(<T = unknown>(layout: StructLayout): ReadStruct<T> => {
+    const [body, usedViews] = generateStructBody(layout);
+    const views = Object.entries(usedViews)
+        .filter(([, used]) => used)
+        .map(([type]) => `${type}: __${type}`)
+        .join(', ');
+
+    const code = `const { ${views} } = data;
+index *= ${layout.size / 4};
+return ${body};`;
+    return new Function('data', 'index', code) as ReadStruct<T>;
+});

package/src/typed-buffer/structs/create-write-struct.ts

@@ -0,0 +1,73 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+import { memoizeFactory } from "../../internal/function/memoize-factory.js";
+import type { StructLayout } from "./struct-layout.js";
+import type { WriteStruct } from "./write-struct.js";
+import { getFieldOffset } from "./get-field-offset.js";
+
+type ViewType = 'f32' | 'i32' | 'u32';
+type ViewTypes = Record<ViewType, boolean>;
+
+const generateStructBody = (
+    layout: StructLayout,
+    parentOffset = '',
+    valueRef = 'value',
+    indent = '    ',
+    usedViews: ViewTypes = { f32: false, i32: false, u32: false }
+): [string, ViewTypes] => {
+    if (typeof layout === 'string') {
+        usedViews[layout as ViewType] = true;
+        return [`__${layout}[${parentOffset}] = ${valueRef};`, usedViews];
+    }
+
+    const entries = layout.type === 'array' ?
+        Object.entries(layout.fields).sort((a, b) => +a[0] - +b[0]) :
+        Object.entries(layout.fields);
+
+    let body = '';
+    for (const [name, field] of entries) {
+        const fieldOffset = getFieldOffset(field, parentOffset);
+        const nextValueRef = layout.type === 'array' ? `${valueRef}[${name}]` : `${valueRef}.${name}`;
+
+        if (typeof field.type === 'string') {
+            usedViews[field.type as ViewType] = true;
+            body += `\n${indent}__${field.type}[${fieldOffset}] = ${nextValueRef};`;
+        } else {
+            const [nestedBody] = generateStructBody(field.type, fieldOffset, nextValueRef, indent + '    ', usedViews);
+            body += `\n${indent}${nestedBody}`;
+        }
+    }
+    return [body, usedViews];
+};
+
+export const createWriteStruct = memoizeFactory(<T = unknown>(layout: StructLayout): WriteStruct<T> => {
+    const [body, usedViews] = generateStructBody(layout);
+    const views = Object.entries(usedViews)
+        .filter(([, used]) => used)
+        .map(([type]) => `${type}: __${type}`)
+        .join(', ');
+
+    const code = `const { ${views} } = data;
+index *= ${layout.size / 4};
+${body};`;
+    return new Function('data', 'index', 'value', code) as WriteStruct<T>;
+});

package/src/typed-buffer/structs/get-field-offset.ts

@@ -0,0 +1,36 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+import { StructLayout } from "./struct-layout.js";
+
+export const getFieldOffset = (field: StructLayout['fields'][string], parentOffset: string): string => {
+    const fieldOffset = field.offset / 4;
+    if (!parentOffset) {
+        return `index + ${fieldOffset}`;
+    }
+    // If parentOffset is a number, add it to fieldOffset
+    const match = parentOffset.match(/^index \+ (\d+)$/);
+    if (match) {
+        const parentNum = parseInt(match[1]);
+        return `index + ${parentNum + fieldOffset}`;
+    }
+    return `${parentOffset} + ${fieldOffset}`;
+};

package/src/typed-buffer/structs/get-struct-layout.test.ts

@@ -0,0 +1,146 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+import { describe, it, expect } from "vitest";
+import { getStructLayout } from "./get-struct-layout.js";
+import type { Schema } from "../../schema/schema.js";
+import { F32Schema } from "../../schema/f32.js";
+import { U32Schema } from "../../schema/u32.js";
+import { I32Schema } from "../../schema/i32.js";
+
+describe("getStructLayout", () => {
+    it("should handle primitive types", () => {
+        const schema: Schema = {
+            type: "object",
+            properties: {
+                a: F32Schema,
+                b: U32Schema,
+                c: I32Schema,
+            }
+        };
+
+        const layout = getStructLayout(schema);
+        expect(layout.type).toBe("object");
+        expect(layout.size).toBe(16);  // rounded to vec4
+        expect(layout.fields.a.offset).toBe(0);
+        expect(layout.fields.b.offset).toBe(4);
+        expect(layout.fields.c.offset).toBe(8);
+    });
+
+    it("should handle vec3 with proper padding", () => {
+        const schema: Schema = {
+            type: "array",
+            items: { type: "number", precision: 1 },
+            minItems: 3,
+            maxItems: 3
+        };
+
+        const layout = getStructLayout(schema)!;
+        expect(layout.type).toBe("array");
+        expect(layout.size).toBe(16);  // padded to vec4
+        expect(layout.fields["0"].offset).toBe(0);
+        expect(layout.fields["1"].offset).toBe(4);
+        expect(layout.fields["2"].offset).toBe(8);
+    });
+
+    it("should handle nested structs", () => {
+        const schema: Schema = {
+            type: "object",
+            properties: {
+                transform: {
+                    type: "object",
+                    properties: {
+                        position: {
+                            type: "array",
+                            items: F32Schema,
+                            minItems: 3,
+                            maxItems: 3
+                        },
+                        scale: F32Schema
+                    }
+                },
+                active: U32Schema
+            }
+        };
+
+        const layout = getStructLayout(schema)!;
+        expect(layout.type).toBe("object");
+        // transform (32 bytes) + active (4 bytes) = 36 bytes
+        // rounded up to largest member alignment (16 bytes) = 48 bytes
+        expect(layout.size).toBe(48);
+        
+        const transform = layout.fields.transform.type;
+        expect(typeof transform).not.toBe("string");
+        if (typeof transform !== "string") {
+            // position (vec3 = 16 bytes) + scale (4 bytes) = 20 bytes
+            // rounded up to largest member alignment (16 bytes) = 32 bytes
+            expect(transform.size).toBe(32);
+            const position = transform.fields.position.type;
+            expect(typeof position !== "string" && position.size).toBe(16);
+        }
+    });
+
+    it("should handle array of structs", () => {
+        const schema: Schema = {
+            type: "array",
+            items: {
+                type: "object",
+                properties: {
+                    x: { type: "number", precision: 1 },
+                    y: { type: "number", precision: 1 }
+                }
+            },
+            minItems: 2,
+            maxItems: 2
+        };
+
+        const layout = getStructLayout(schema)!;
+        expect(layout.type).toBe("array");
+        expect(layout.size).toBe(32);  // 2 structs aligned to vec4
+        expect(layout.fields["0"].offset).toBe(0);
+        expect(layout.fields["1"].offset).toBe(16);  // aligned to vec4
+    });
+
+    it("should reject invalid schemas", () => {
+        // Non-fixed length array
+        expect(() => getStructLayout({
+            type: "array",
+            items: { type: "number", precision: 1 }
+        })).toThrow();
+
+        // Invalid primitive type
+        expect(() => getStructLayout({
+            type: "object",
+            properties: {
+                a: { type: "string" }
+            }
+        })).toThrow();
+
+        // Array length < 2
+        expect(() => getStructLayout({
+            type: "array",
+            items: { type: "number", precision: 1 },
+            minItems: 1,
+            maxItems: 1
+        })).toThrow();
+    });
+
+}); 

package/src/typed-buffer/structs/get-struct-layout.ts

@@ -0,0 +1,222 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+import { memoizeFactory } from "../../internal/function/memoize-factory.js";
+import { I32Schema } from "../../schema/i32.js";
+import { type Schema } from "../../schema/schema.js";
+import { U32Schema } from "../../schema/u32.js";
+import type { StructFieldPrimitiveType, StructLayout } from "./struct-layout.js";
+
+// Constants for std140 layout
+const VEC4_SIZE = 16;  // size in bytes
+
+/**
+ * Gets alignment in bytes for a field within a struct
+ * Adheres to WebGPU std140 layout rules
+ */
+const getStructFieldAlignment = (type: StructFieldPrimitiveType | StructLayout): number => {
+    // Primitive types are 4-byte aligned
+    if (typeof type === "string") {
+        return 4;
+    }
+    // Arrays are aligned to vec4 (16 bytes)
+    if (type.type === "array") {
+        return VEC4_SIZE;
+    }
+    // Structs are aligned to 4 bytes within other structs
+    return 4;
+};
+
+/**
+ * Gets size in bytes for a field type
+ */
+const getFieldSize = (type: StructFieldPrimitiveType | StructLayout): number => {
+    if (typeof type === "string") {
+        return 4;  // All primitives are 4 bytes
+    }
+    return type.size;
+};
+
+/**
+ * Gets stride in bytes for an array element type
+ * In std140, array elements are aligned to vec4 if they are arrays/structs
+ * but primitives just use their natural alignment
+ */
+const getArrayElementStride = (type: StructFieldPrimitiveType | StructLayout): number => {
+    // For primitives in arrays, use 4 bytes
+    if (typeof type === "string") {
+        return 4;
+    }
+    // For structs and arrays, round up to vec4
+    return roundUpToAlignment(type.size, VEC4_SIZE);
+};
+
+/**
+ * Gets alignment for array elements
+ * In std140, array elements are aligned to vec4 if they are arrays/structs
+ * but primitives just use their natural alignment
+ */
+const getArrayElementAlignment = (type: StructFieldPrimitiveType | StructLayout): number => {
+    if (typeof type === "string") {
+        return 4;  // Primitives use natural alignment
+    }
+    return VEC4_SIZE;  // Arrays and structs align to vec4
+};
+
+/**
+ * Rounds up to the next multiple of alignment
+ */
+const roundUpToAlignment = (offset: number, alignment: number): number => {
+    return Math.ceil(offset / alignment) * alignment;
+};
+
+/**
+ * Converts a primitive schema type to a StructFieldPrimitiveType or returns null if not a valid primitive type
+ */
+const getPrimitiveType = (schema: Schema): StructFieldPrimitiveType | null => {
+    if (schema.type === "number" || schema.type === "integer") {
+        if (schema.type === "integer") {
+            if (schema.minimum !== undefined && schema.minimum >= 0 && schema.maximum && schema.maximum <= U32Schema.maximum) {
+                return "u32";
+            }
+            if (schema.minimum !== undefined && schema.minimum < 0 && schema.maximum && schema.maximum <= I32Schema.maximum) {
+                return "i32";
+            }
+        }
+        else if (schema.precision === 1 || schema.precision === 2) {
+            return "f32";
+        }
+    }
+
+    return null;
+};
+
+/**
+ * Analyzes a Schema and returns a StructLayout.
+ * Returns null if schema is not a valid struct schema.
+ */
+const getStructLayoutInternal = memoizeFactory((schema: Schema): StructLayout | null => {
+    // Handle root array/tuple case
+    if (schema.type === "array") {
+        if (!schema.items || Array.isArray(schema.items)) {
+            throw new Error("Array schema must have single item type");
+        }
+        if (schema.minItems !== schema.maxItems || !schema.minItems) {
+            throw new Error("Array must have fixed length");
+        }
+        if (schema.minItems < 2) {
+            throw new Error("Array length must be at least 2");
+        }
+
+        // Special case for vec3
+        const primitiveType = getPrimitiveType(schema.items);
+        if (primitiveType && schema.minItems === 3) {
+            const fields: StructLayout["fields"] = {};
+            for (let i = 0; i < 3; i++) {
+                fields[i.toString()] = {
+                    offset: i * 4,
+                    type: primitiveType
+                };
+            }
+            return {
+                type: "array",
+                size: VEC4_SIZE,  // vec3 is padded to vec4
+                fields
+            };
+        }
+
+        // Regular array case
+        const fields: StructLayout["fields"] = {};
+        const elementType = primitiveType ?? getStructLayoutInternal(schema.items);
+        if (!elementType) {
+            return null;
+        }
+        let currentOffset = 0;
+
+        // Arrays are aligned to vec4 boundary
+        currentOffset = roundUpToAlignment(currentOffset, VEC4_SIZE);
+        const elementAlignment = getArrayElementAlignment(elementType);
+        const stride = getArrayElementStride(elementType);
+
+        for (let i = 0; i < schema.minItems; i++) {
+            // Align each element according to its type
+            currentOffset = roundUpToAlignment(currentOffset, elementAlignment);
+            fields[i.toString()] = {
+                offset: currentOffset,
+                type: elementType
+            };
+            currentOffset += stride;
+        }
+
+        // Total size must be rounded up to vec4
+        const size = roundUpToAlignment(currentOffset, VEC4_SIZE);
+        return {
+            type: "array",
+            size,
+            fields
+        };
+    }
+
+    // Handle object case
+    if (schema.type !== "object" || !schema.properties) {
+        return null;
+    }
+
+    const fields: StructLayout["fields"] = {};
+    let currentOffset = 0;
+
+    // First pass: create all fields and calculate alignments
+    for (const [name, fieldSchema] of Object.entries(schema.properties)) {
+        const primitiveType = getPrimitiveType(fieldSchema);
+        const fieldType = primitiveType ?? getStructLayoutInternal(fieldSchema);
+        if (!fieldType) {
+            return null;
+        }
+        const alignment = getStructFieldAlignment(fieldType);
+
+        // Align field to its required alignment
+        currentOffset = roundUpToAlignment(currentOffset, alignment);
+        fields[name] = {
+            offset: currentOffset,
+            type: fieldType
+        };
+        currentOffset += getFieldSize(fieldType);
+    }
+
+    // Round up total size to vec4
+    const size = roundUpToAlignment(currentOffset, VEC4_SIZE);
+    return {
+        type: "object",
+        size,
+        fields
+    };
+});
+
+export function getStructLayout(schema: Schema): StructLayout
+export function getStructLayout(schema: Schema, throwError: true): StructLayout
+export function getStructLayout(schema: Schema, throwError: boolean): StructLayout | null
+export function getStructLayout(schema: Schema, throwError = true): StructLayout | null {
+    const layout = getStructLayoutInternal(schema);
+    if (layout === null && throwError) {
+        throw new Error("Invalid structure schema");
+    }
+    return layout;
+}

package/src/typed-buffer/structs/index.ts

@@ -0,0 +1,22 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+export { getStructLayout } from "./get-struct-layout.js";

package/src/typed-buffer/structs/read-struct.ts

@@ -0,0 +1,25 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+import type { DataView32 } from "../../internal/data-view-32/data-view-32.js";
+
+export type ReadStruct<T> = (data: DataView32, index: number) => T;
+