typegpu 0.12.2 → 0.12.4

package/core/pipeline/connectTargetsToShader.js

@@ -3,7 +3,7 @@ import { isVoid, isWgslStruct } from "../../data/wgslTypes.js";
 export function connectTargetsToShader(fragmentOut, targets) {
     let presentationFormat;
     if (isVoid(fragmentOut) || isBuiltin(fragmentOut)) {
-        return [null];
+        return [];
     }
     if (isWgslStruct(fragmentOut)) {
         const result = [];

package/core/pipeline/renderPipeline.js

@@ -409,7 +409,7 @@ class RenderPipelineCore {
         // One other reason is that if the shelled fragment has already been resolved in this namespace,
         // then this.#latestAutoFragmentOut will be undefined.
         const fragmentOut = fragment?.shell?.returnType ?? this.#latestAutoFragmentOut;
-        const connectedTargets = fragmentOut ? connectTargetsToShader(fragmentOut, targets) : [null];
+        const connectedTargets = fragmentOut ? connectTargetsToShader(fragmentOut, targets) : [];
         const descriptor = {
             layout: device.createPipelineLayout({
                 label: `${getName(this) ?? '<unnamed>'} - Pipeline Layout`,

package/data/assignInfixOperators.d.ts

@@ -1 +1 @@
-export {};
+export declare function assignInfixOperators(): void;

package/data/assignInfixOperators.js

@@ -2,13 +2,20 @@ import { Operator } from 'tsover-runtime';
 import { MatBase } from "./matrix.js";
 import { VecBase } from "./vectorImpl.js";
 import { assignInfixOperator } from "../tgsl/infixDispatch.js";
-assignInfixOperator(VecBase, 'add', Operator.plus);
-assignInfixOperator(MatBase, 'add', Operator.plus);
-assignInfixOperator(VecBase, 'sub', Operator.minus);
-assignInfixOperator(MatBase, 'sub', Operator.minus);
-assignInfixOperator(VecBase, 'mul', Operator.star);
-assignInfixOperator(MatBase, 'mul', Operator.star);
-assignInfixOperator(VecBase, 'div', Operator.slash);
-assignInfixOperator(VecBase, 'mod', Operator.percent);
-assignInfixOperator(VecBase, 'bitShiftLeft', Symbol()); // bitShift does not yet have tsover operator symbol
-assignInfixOperator(VecBase, 'bitShiftRight', Symbol()); // bitShift does not yet have tsover operator symbol
+let infixOperatorsAssigned = false;
+export function assignInfixOperators() {
+    if (infixOperatorsAssigned) {
+        return;
+    }
+    infixOperatorsAssigned = true;
+    assignInfixOperator(VecBase, 'add', Operator.plus);
+    assignInfixOperator(MatBase, 'add', Operator.plus);
+    assignInfixOperator(VecBase, 'sub', Operator.minus);
+    assignInfixOperator(MatBase, 'sub', Operator.minus);
+    assignInfixOperator(VecBase, 'mul', Operator.star);
+    assignInfixOperator(MatBase, 'mul', Operator.star);
+    assignInfixOperator(VecBase, 'div', Operator.slash);
+    assignInfixOperator(VecBase, 'mod', Operator.percent);
+    assignInfixOperator(VecBase, 'bitShiftLeft', Symbol()); // bitShift does not yet have tsover operator symbol
+    assignInfixOperator(VecBase, 'bitShiftRight', Symbol()); // bitShift does not yet have tsover operator symbol
+}

package/data/index.d.ts

@@ -1,7 +1,24 @@
 /**
  * @module typegpu/data
  */
-import './assignInfixOperators.ts';
+export declare const vec2b: import("./wgslTypes.ts").Vec2b;
+export declare const vec2f: import("./wgslTypes.ts").Vec2f;
+export declare const vec2h: import("./wgslTypes.ts").Vec2h;
+export declare const vec2i: import("./wgslTypes.ts").Vec2i;
+export declare const vec2u: import("./wgslTypes.ts").Vec2u;
+export declare const vec3b: import("./wgslTypes.ts").Vec3b;
+export declare const vec3f: import("./wgslTypes.ts").Vec3f;
+export declare const vec3h: import("./wgslTypes.ts").Vec3h;
+export declare const vec3i: import("./wgslTypes.ts").Vec3i;
+export declare const vec3u: import("./wgslTypes.ts").Vec3u;
+export declare const vec4b: import("./wgslTypes.ts").Vec4b;
+export declare const vec4f: import("./wgslTypes.ts").Vec4f;
+export declare const vec4h: import("./wgslTypes.ts").Vec4h;
+export declare const vec4i: import("./wgslTypes.ts").Vec4i;
+export declare const vec4u: import("./wgslTypes.ts").Vec4u;
+export declare const mat2x2f: import("./wgslTypes.ts").Mat2x2f;
+export declare const mat3x3f: import("./wgslTypes.ts").Mat3x3f;
+export declare const mat4x4f: import("./wgslTypes.ts").Mat4x4f;
 export { bool, f16, f32, i32, u16, u32 } from './numeric.ts';
 export { isAlignAttrib, isAtomic, isBuiltinAttrib, isDecorated, isInterpolateAttrib, isInvariantAttrib, isLocationAttrib, isPtr, isSizeAttrib, isWgslArray, isWgslData, isWgslStruct, Void, } from './wgslTypes.ts';
 export type { Align, AnyVecInstance, AnyWgslData, AnyWgslStruct, Atomic, atomicI32, atomicU32, BaseData, BaseData as BaseWgslData, Bool, Builtin, Decorated, F16, F32, I32, Interpolate, Invariant, Location, m2x2f, m3x3f, m4x4f, Mat2x2f, Mat3x3f, Mat4x4f, matBase, Ptr, Size, StorableData, U16, U32, v2b, v2f, v2h, v2i, v2u, v3b, v3f, v3h, v3i, v3u, v4b, v4f, v4h, v4i, v4u, Vec2b, Vec2f, Vec2h, Vec2i, Vec2u, Vec3b, Vec3f, Vec3h, Vec3i, Vec3u, Vec4b, Vec4f, Vec4h, Vec4i, Vec4u, vecBase, WgslArray, WgslStruct, } from './wgslTypes.ts';
@@ -11,10 +28,9 @@ export { ptrFn, ptrHandle, ptrPrivate, ptrStorage, ptrUniform, ptrWorkgroup } fr
 export type { AnyData, AnyLooseData, Disarray, LooseDecorated, Unstruct } from './dataTypes.ts';
 export { texture1d, texture2d, texture2dArray, texture3d, textureCube, textureCubeArray, textureDepth2d, textureDepth2dArray, textureDepthCube, textureDepthCubeArray, textureDepthMultisampled2d, textureExternal, textureMultisampled2d, textureStorage1d, textureStorage2d, textureStorage2dArray, textureStorage3d, type WgslExternalTexture, type WgslStorageTexture, type WgslStorageTexture1d, type WgslStorageTexture2d, type WgslStorageTexture2dArray, type WgslStorageTexture3d, type WgslStorageTextureProps, type WgslTexture, type WgslTexture1d, type WgslTexture2d, type WgslTexture2dArray, type WgslTexture3d, type WgslTextureCube, type WgslTextureCubeArray, type WgslTextureDepth2d, type WgslTextureDepth2dArray, type WgslTextureDepthCube, type WgslTextureDepthCubeArray, type WgslTextureDepthMultisampled2d, type WgslTextureMultisampled2d, } from './texture.ts';
 export { comparisonSampler, sampler, type WgslComparisonSampler, type WgslSampler, } from './sampler.ts';
-export { vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u, } from './vector.ts';
 export { disarrayOf } from './disarray.ts';
 export { unstruct } from './unstruct.ts';
-export { mat2x2f, mat3x3f, mat4x4f, matToArray } from './matrix.ts';
+export { matToArray } from './matrix.ts';
 export * from './vertexFormatData.ts';
 export { atomic } from './atomic.ts';
 export { _ref as ref } from './ref.ts';

package/data/index.js

@@ -2,8 +2,27 @@
  * @module typegpu/data
  */
 // NOTE: This is a barrel file, internal files should not import things from this file
-// oxlint-disable-next-line import/no-unassigned-import -- this import has side effects
-import "./assignInfixOperators.js";
+import { assignInfixOperators } from "./assignInfixOperators.js";
+import { vec2b as _vec2b, vec2f as _vec2f, vec2h as _vec2h, vec2i as _vec2i, vec2u as _vec2u, vec3b as _vec3b, vec3f as _vec3f, vec3h as _vec3h, vec3i as _vec3i, vec3u as _vec3u, vec4b as _vec4b, vec4f as _vec4f, vec4h as _vec4h, vec4i as _vec4i, vec4u as _vec4u, } from "./vector.js";
+export const vec2b = (() => (assignInfixOperators(), _vec2b))();
+export const vec2f = (() => (assignInfixOperators(), _vec2f))();
+export const vec2h = (() => (assignInfixOperators(), _vec2h))();
+export const vec2i = (() => (assignInfixOperators(), _vec2i))();
+export const vec2u = (() => (assignInfixOperators(), _vec2u))();
+export const vec3b = (() => (assignInfixOperators(), _vec3b))();
+export const vec3f = (() => (assignInfixOperators(), _vec3f))();
+export const vec3h = (() => (assignInfixOperators(), _vec3h))();
+export const vec3i = (() => (assignInfixOperators(), _vec3i))();
+export const vec3u = (() => (assignInfixOperators(), _vec3u))();
+export const vec4b = (() => (assignInfixOperators(), _vec4b))();
+export const vec4f = (() => (assignInfixOperators(), _vec4f))();
+export const vec4h = (() => (assignInfixOperators(), _vec4h))();
+export const vec4i = (() => (assignInfixOperators(), _vec4i))();
+export const vec4u = (() => (assignInfixOperators(), _vec4u))();
+import { mat2x2f as _mat2x2f, mat3x3f as _mat3x3f, mat4x4f as _mat4x4f } from "./matrix.js";
+export const mat2x2f = (() => (assignInfixOperators(), _mat2x2f))();
+export const mat3x3f = (() => (assignInfixOperators(), _mat3x3f))();
+export const mat4x4f = (() => (assignInfixOperators(), _mat4x4f))();
 export { bool, f16, f32, i32, u16, u32 } from "./numeric.js";
 export { isAlignAttrib, isAtomic, isBuiltinAttrib, isDecorated, isInterpolateAttrib, isInvariantAttrib, isLocationAttrib, isPtr, isSizeAttrib, isWgslArray, isWgslData, isWgslStruct, Void, } from "./wgslTypes.js";
 export { struct } from "./struct.js";
@@ -11,10 +30,9 @@ export { arrayOf } from "./array.js";
 export { ptrFn, ptrHandle, ptrPrivate, ptrStorage, ptrUniform, ptrWorkgroup } from "./ptr.js";
 export { texture1d, texture2d, texture2dArray, texture3d, textureCube, textureCubeArray, textureDepth2d, textureDepth2dArray, textureDepthCube, textureDepthCubeArray, textureDepthMultisampled2d, textureExternal, textureMultisampled2d, textureStorage1d, textureStorage2d, textureStorage2dArray, textureStorage3d, } from "./texture.js";
 export { comparisonSampler, sampler, } from "./sampler.js";
-export { vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u, } from "./vector.js";
 export { disarrayOf } from "./disarray.js";
 export { unstruct } from "./unstruct.js";
-export { mat2x2f, mat3x3f, mat4x4f, matToArray } from "./matrix.js";
+export { matToArray } from "./matrix.js";
 export * from "./vertexFormatData.js";
 export { atomic } from "./atomic.js";
 export { _ref as ref } from "./ref.js";

package/index.d.ts

@@ -4,7 +4,7 @@
 
 // NOTE: This is a barrel file, internal files should not import things from this file
 
-export declare const tgpu: {
+declare const tgpu_default: {
   const: typeof import('./core/constant/tgpuConstant.ts').constant;
   fn: typeof import('./core/function/tgpuFn.ts').fn;
   comptime: typeof import('./core/function/comptime.ts').comptime;
@@ -28,6 +28,7 @@ export declare const tgpu: {
   '~unstable': typeof import('./tgpuUnstable.ts');
 };
 
-export default tgpu;
+export { tgpu_default as tgpu };
+export default tgpu_default;
 
 export * from './indexNamedExports.ts';

package/index.js

@@ -2,7 +2,6 @@
  * @module typegpu
  */
 // NOTE: This is a barrel file, internal files should not import things from this file
-import * as tgpu from "./tgpu.js";
 export * as tgpu from "./tgpu.js";
-export default tgpu;
+export * as default from "./tgpu.js";
 export * from "./indexNamedExports.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typegpu",
-  "version": "0.12.2",
+  "version": "0.12.4",
   "description": "A thin layer between JS and WebGPU/WGSL that improves development experience and allows for faster iteration.",
   "keywords": [
     "compute",
@@ -23,9 +23,7 @@
     "directory": "packages/typegpu"
   },
   "type": "module",
-  "sideEffects": [
-    "./data/assignInfixOperators.js"
-  ],
+  "sideEffects": false,
   "exports": {
     "./package.json": "./package.json",
     ".": {
@@ -52,7 +50,7 @@
   "dependencies": {
     "tsover-runtime": "^0.0.7",
     "typed-binary": "^4.3.3",
-    "tinyest": "~0.3.2"
+    "tinyest": "~0.3.3"
   },
   "engines": {
     "node": ">=12.20.0"

package/resolutionCtx.js

@@ -845,6 +845,9 @@ export class ResolutionCtxImpl {
         if (schema && isWgslStruct(schema)) {
             return this.gen.typeInstantiation(schema, Object.entries(schema.propTypes).map(([key, propType]) => snip(item[key], propType, /* origin */ 'runtime')));
         }
+        if (item === null) {
+            throw new WgslTypeError(`'null' is not resolvable. 'null' is only allowed in comptime checks.`);
+        }
         throw new WgslTypeError(`Value ${safeStringify(item)} is not resolvable${schema && schema !== UnknownData ? ` to type ${safeStringify(schema)}` : ''}`);
     }
     resolveSnippet(snippet) {

package/shared/meta.js

@@ -1,4 +1,4 @@
-const version = "0.12.2";
+const version = "0.12.4";
 import { DEV, TEST } from "./env.js";
 import { $getNameForward, $soul, isMarkedInternal } from "./symbols.js";
 import { normalizeMetadata } from "./normalizeMetadata.js";

package/shared/symbols.js

@@ -1,4 +1,4 @@
-const version = "0.12.2";
+const version = "0.12.4";
 export const $internal = Symbol(`typegpu:${version}:$internal`);
 /** A plain record of all definitional state of a resource, surviving transfer between runtimes */
 export const $soul = Symbol(`typegpu:${version}:$soul`);

package/shared/tseynit.js

@@ -124,6 +124,9 @@ function stringifyExpression(node, ident) {
     if (node[0] === NODE.conditionalExpr) {
         return `${wrapIfComplex(node[1], ident)} ? ${wrapIfComplex(node[2], ident)} : ${wrapIfComplex(node[3], ident)}`;
     }
+    if (node[0] === NODE.nullLiteral) {
+        return 'null';
+    }
     assertExhaustive(node);
 }
 function assertExhaustive(value) {
@@ -145,7 +148,8 @@ function isExpression(node) {
         node[0] === NODE.preUpdate ||
         node[0] === NODE.postUpdate ||
         node[0] === NODE.objectExpr ||
-        node[0] === NODE.conditionalExpr) {
+        node[0] === NODE.conditionalExpr ||
+        node[0] === NODE.nullLiteral) {
         node;
         return true;
     }

package/tgsl/wgslGenerator.js

@@ -734,6 +734,9 @@ export class WgslGenerator {
         if (expression[0] === NODE.preUpdate) {
             throw new Error('Cannot use pre-updates in TypeGPU functions.');
         }
+        if (expression[0] === NODE.nullLiteral) {
+            return snip(null, UnknownData, 'constant', false);
+        }
         assertExhaustive(expression);
     }
     declareGlobalConst(options) {