typegpu 0.11.8 → 0.12.0

package/indexNamedExports.d.ts

@@ -1,43 +1,70 @@
-import { INTERNAL_GlobalExt } from "./shared/meta.js";
-import { Storage, StorageFlag, isUsableAsStorage } from "./extension.js";
-import { TgpuQuerySet } from "./core/querySet/querySet.js";
-import { TgpuBufferMutable, TgpuBufferReadonly, TgpuBufferUniform, isUsableAsUniform } from "./core/buffer/bufferUsage.js";
-import { TgpuMutable, TgpuReadonly, TgpuUniform, isBufferShorthand } from "./core/buffer/bufferShorthand.js";
-import { TgpuComputeFn, TgpuComputeFnShell, isTgpuComputeFn } from "./core/function/tgpuComputeFn.js";
-import { TgpuVar, VariableScope, isVariable } from "./core/variable/tgpuVariable.js";
-import { Eventual, TgpuAccessor, TgpuLazy, TgpuMutableAccessor, TgpuSlot, isAccessor, isLazy, isMutableAccessor, isSlot } from "./core/slot/slotTypes.js";
-import { TgpuComputePipeline } from "./core/pipeline/computePipeline.js";
-import { AnyAutoCustoms, AutoFragmentIn, AutoFragmentOut, AutoVertexOut, _AutoVertexIn } from "./core/function/autoIO.js";
-import { TgpuFragmentFn, TgpuFragmentFnShell, isTgpuFragmentFn } from "./core/function/tgpuFragmentFn.js";
-import { TgpuVertexFn, TgpuVertexFnShell, isTgpuVertexFn } from "./core/function/tgpuVertexFn.js";
-import { TextureProps } from "./core/texture/textureProps.js";
-import { RenderFlag, SampledFlag, isUsableAsRender, isUsableAsSampled } from "./core/texture/usageExtension.js";
-import { TgpuVertexLayout } from "./core/vertexLayout/vertexLayout.js";
-import { ColorAttachment, TgpuPrimitiveState, TgpuRenderPipeline } from "./core/pipeline/renderPipeline.js";
-import { TgpuComparisonSampler, TgpuFixedComparisonSampler, TgpuFixedSampler, TgpuSampler, isComparisonSampler, isSampler } from "./core/sampler/sampler.js";
-import { BindLayoutEntry, ExtractBindGroupInputFromLayout, LayoutEntryToInput, TgpuBindGroup, TgpuBindGroupLayout, TgpuLayoutComparisonSampler, TgpuLayoutEntry, TgpuLayoutExternalTexture, TgpuLayoutSampler, TgpuLayoutStorage, TgpuLayoutTexture, TgpuLayoutUniform } from "./tgpuBindGroupLayout.js";
-import { ShaderGenerator } from "./tgsl/shaderGenerator.js";
-import { Configurable, TgpuGuardedComputePipeline, TgpuRoot, ValidateBufferSchema, ValidateStorageSchema, ValidateUniformSchema, WithBinding, WithCompute, WithFragment, WithVertex, Withable } from "./core/root/rootTypes.js";
-import { IndexFlag, TgpuBuffer, Uniform, UniformFlag, ValidUsagesFor, Vertex, VertexFlag, isBuffer, isUsableAsVertex } from "./core/buffer/buffer.js";
-import { TgpuDeclare } from "./core/declare/tgpuDeclare.js";
-import { TgpuFn, TgpuFnShell, TgpuGenericFn, isTgpuFn } from "./core/function/tgpuFn.js";
-import { TgpuTexture, TgpuTextureView, isTexture } from "./core/texture/texture.js";
-import { TgpuConst } from "./core/constant/tgpuConstant.js";
-import { TgpuComptime } from "./core/function/comptime.js";
-import { Namespace } from "./core/resolve/namespace.js";
-import { InitFromDeviceOptions, InitOptions } from "./core/root/init.js";
-import { RawCodeSnippetOrigin, TgpuRawCodeSnippet } from "./core/rawCodeSnippet/tgpuRawCodeSnippet.js";
-import { index_d_exports } from "./data/index.js";
-import { index_d_exports as index_d_exports$1 } from "./std/index.js";
-import { index_d_exports as index_d_exports$2 } from "./common/index.js";
-import { MissingBindGroupsError, MissingSlotValueError, MissingVertexBuffersError, NotUniformError, ResolutionError } from "./errors.js";
-import { WgslGenerator } from "./tgsl/wgslGenerator.js";
-import { readFromArrayBuffer, writeToArrayBuffer } from "./data/dataIO.js";
-import { patchArrayBuffer } from "./data/partialIO.js";
-
-//#region src/indexNamedExports.d.ts
-
+export * as d from './data/index.ts';
+export * as std from './std/index.ts';
+export * as common from './common/index.ts';
+export { MissingBindGroupsError, MissingSlotValueError, MissingVertexBuffersError, NotUniformError, ResolutionError, } from './errors.ts';
+export { isAccessor, isLazy, isMutableAccessor, isSlot } from './core/slot/slotTypes.ts';
+export { isComparisonSampler, isSampler } from './core/sampler/sampler.ts';
+export { isTexture } from './core/texture/texture.ts';
+export { isUsableAsRender, isUsableAsSampled } from './core/texture/usageExtension.ts';
+export { isBuffer, isUsableAsUniform, isUsableAsVertex, isUsableAsIndex, isUsableAsStorage, } from './types.ts';
+export { isBufferBinding, isBufferShorthand, isMutableBinding, isReadonlyBinding, isUniformBinding, } from './core/buffer/bufferBinding.ts';
+export { isBindGroup, isBindGroupLayout } from './tgpuBindGroupLayout.ts';
+export { isTgpuFn } from './core/function/tgpuFn.ts';
+export { isTgpuFragmentFn } from './core/function/tgpuFragmentFn.ts';
+export { isTgpuVertexFn } from './core/function/tgpuVertexFn.ts';
+export { isTgpuComputeFn } from './core/function/tgpuComputeFn.ts';
+export { isComputePipeline, isPipeline, isRenderPipeline } from './core/pipeline/typeGuards.ts';
+export { isQuerySet } from './core/querySet/querySet.ts';
+export { isVariable } from './core/variable/tgpuVariable.ts';
+export { isVertexLayout } from './core/vertexLayout/vertexLayout.ts';
+export type { 
+/** @deprecated Import from 'typegpu/~internal' instead */ ShaderGenerator, } from './tgsl/shaderGenerator.ts';
+export { 
+/** @deprecated Import from 'typegpu/~internal' instead */ WgslGenerator, } from './tgsl/wgslGenerator.ts';
+export { readFromArrayBuffer, writeToArrayBuffer } from './data/dataIO.ts';
+export { patchArrayBuffer } from './data/partialIO.ts';
+export { warn } from './tgpuLogger.ts';
+export type { ResolvableObject, ShaderStage } from './types.ts';
+export type { ResolvedDeclaration } from './resolutionCtx.ts';
+export type { Configurable, TgpuGuardedComputePipeline, TgpuRoot, ValidateBufferSchema, ValidateStorageSchema, ValidateUniformSchema, Withable, WithBinding, } from './core/root/rootTypes.ts';
+export type { Storage, StorageFlag } from './extension.ts';
+export type { TgpuVertexLayout } from './core/vertexLayout/vertexLayout.ts';
+export type { TgpuPrimitiveState, TgpuRenderPipeline } from './core/pipeline/renderPipeline.ts';
+export type { ColorAttachment, DepthStencilAttachment } from './core/commandEncoder/attachments.ts';
+export type { TgpuComputePipeline } from './core/pipeline/computePipeline.ts';
+export type { TgpuCommandEncoder } from './core/commandEncoder/commandEncoder.ts';
+export type { TgpuRenderBundleEncoder, TgpuRenderCommands, TgpuRenderPass, TgpuRenderPassDescriptor, } from './core/commandEncoder/renderPass.ts';
+export type { TgpuComputePass, TgpuComputePassDescriptor, } from './core/commandEncoder/computePass.ts';
+export type { IndexFlag, TgpuBuffer, Uniform, UniformFlag, UsageLiteral, ValidUsagesFor, Vertex, VertexFlag, TgpuStorageBuffer, TgpuUniformBuffer, TgpuVertexBuffer, TgpuIndexBuffer, BufferWriteOptions, BufferInitCallback, BufferInitialData, } from './core/buffer/buffer.ts';
+export type { TgpuBufferMutable, TgpuBufferReadonly, TgpuBufferUniform, } from './core/buffer/bufferUsage.ts';
+export type { TgpuBufferBinding, TgpuMutable, TgpuReadonly, TgpuUniform, } from './core/buffer/bufferBinding.ts';
+export type { Eventual, TgpuAccessor, TgpuLazy, TgpuMutableAccessor, TgpuSlot, } from './core/slot/slotTypes.ts';
+export type { RawCodeSnippetOrigin, TgpuRawCodeSnippet, } from './core/rawCodeSnippet/tgpuRawCodeSnippet.ts';
+export type { TextureWriteFit, TextureWriteOptions, TgpuTexture, TgpuTextureView, } from './core/texture/texture.ts';
+export type { TextureProps } from './core/texture/textureProps.ts';
+export type { RenderFlag, SampledFlag } from './core/texture/usageExtension.ts';
+export type { InitFromDeviceOptions, InitOptions } from './core/root/init.ts';
+export type { TgpuConst } from './core/constant/tgpuConstant.ts';
+export type { TgpuVar, VariableScope } from './core/variable/tgpuVariable.ts';
+export type { TgpuComparisonSampler, TgpuFixedComparisonSampler, TgpuFixedSampler, TgpuSampler, } from './core/sampler/sampler.ts';
+export type { TgpuQuerySet } from './core/querySet/querySet.ts';
+export type { ExtractBindGroupInputFromLayout, LayoutEntryToInput, TgpuBindGroup, TgpuBindGroupLayout, TgpuLayoutComparisonSampler, TgpuLayoutEntry, TgpuLayoutExternalTexture, TgpuLayoutSampler, TgpuLayoutStorage, TgpuLayoutTexture, TgpuLayoutUniform, } from './tgpuBindGroupLayout.ts';
+export type { TgpuFn, TgpuFnShell, TgpuGenericFn } from './core/function/tgpuFn.ts';
+export type { TgpuComptime } from './core/function/comptime.ts';
+export type { TgpuVertexFn, TgpuVertexFnShell } from './core/function/tgpuVertexFn.ts';
+export type { TgpuFragmentFn, TgpuFragmentFnShell } from './core/function/tgpuFragmentFn.ts';
+export type { TgpuComputeFn, TgpuComputeFnShell } from './core/function/tgpuComputeFn.ts';
+export type { AnyAutoCustoms, 
+/** @deprecated use TgpuFragmentFn.AutoIn */
+AutoFragmentIn, 
+/** @deprecated use TgpuFragmentFn.AutoOut */
+AutoFragmentOut, 
+/** @deprecated use TgpuVertexFn.AutoIn */
+_AutoVertexIn as AutoVertexIn, 
+/** @deprecated use TgpuVertexFn.AutoOut */
+AutoVertexOut, } from './core/function/autoIO.ts';
+export type { TgpuDeclare } from './core/declare/tgpuDeclare.ts';
+export type { Namespace } from './core/resolve/namespace.ts';
+export type { INTERNAL_GlobalExt } from './shared/meta.ts';
 /** @deprecated Use TgpuRenderPipeline.Descriptor */
-type TgpuRenderPipelineDescriptor = TgpuRenderPipeline.Descriptor;
-//#endregion
-export { TgpuRenderPipelineDescriptor };
+export type TgpuRenderPipelineDescriptor = import('./core/pipeline/renderPipeline.ts').TgpuRenderPipeline.Descriptor;

package/indexNamedExports.js

@@ -0,0 +1,25 @@
+// NOTE: This is a barrel file, internal files should not import things from this file
+export * as d from "./data/index.js";
+export * as std from "./std/index.js";
+export * as common from "./common/index.js";
+export { MissingBindGroupsError, MissingSlotValueError, MissingVertexBuffersError, NotUniformError, ResolutionError, } from "./errors.js";
+export { isAccessor, isLazy, isMutableAccessor, isSlot } from "./core/slot/slotTypes.js";
+export { isComparisonSampler, isSampler } from "./core/sampler/sampler.js";
+export { isTexture } from "./core/texture/texture.js";
+export { isUsableAsRender, isUsableAsSampled } from "./core/texture/usageExtension.js";
+export { isBuffer, isUsableAsUniform, isUsableAsVertex, isUsableAsIndex, isUsableAsStorage, } from "./types.js";
+export { isBufferBinding, isBufferShorthand, isMutableBinding, isReadonlyBinding, isUniformBinding, } from "./core/buffer/bufferBinding.js";
+export { isBindGroup, isBindGroupLayout } from "./tgpuBindGroupLayout.js";
+export { isTgpuFn } from "./core/function/tgpuFn.js";
+export { isTgpuFragmentFn } from "./core/function/tgpuFragmentFn.js";
+export { isTgpuVertexFn } from "./core/function/tgpuVertexFn.js";
+export { isTgpuComputeFn } from "./core/function/tgpuComputeFn.js";
+export { isComputePipeline, isPipeline, isRenderPipeline } from "./core/pipeline/typeGuards.js";
+export { isQuerySet } from "./core/querySet/querySet.js";
+export { isVariable } from "./core/variable/tgpuVariable.js";
+export { isVertexLayout } from "./core/vertexLayout/vertexLayout.js";
+export { 
+/** @deprecated Import from 'typegpu/~internal' instead */ WgslGenerator, } from "./tgsl/wgslGenerator.js";
+export { readFromArrayBuffer, writeToArrayBuffer } from "./data/dataIO.js";
+export { patchArrayBuffer } from "./data/partialIO.js";
+export { warn } from "./tgpuLogger.js";

package/internal.d.ts

@@ -0,0 +1,16 @@
+export { abstractInt, abstractFloat } from './data/numeric.ts';
+export { makeResolvable } from './tgsl/makeResolvable.ts';
+export { makeDereferenceable } from './tgsl/makeDereferenceable.ts';
+export { UnknownData } from './data/dataTypes.ts';
+export { getName, setName } from './shared/meta.ts';
+export { WgslGenerator } from './tgsl/wgslGenerator.ts';
+export { snip, withValue, withDataType, withSideEffects } from './data/snippet.ts';
+export { stringifyNode } from './shared/tseynit.ts';
+export { dualImpl } from './core/function/dualImpl.ts';
+export { isNonTransferableResource, isTransferableResource, restoreResource, snapshotResource, } from './serial/registry.ts';
+export type { TgpuResourceSnapshot, TransferableResourceType } from './serial/registry.ts';
+export type { RestoreContext } from './serial/types.ts';
+export { deserializeDataSchema, serializeDataSchema, type SerializedDataSchema, } from './serial/schema.ts';
+export type { ResolutionCtx, FunctionArgument } from './types.ts';
+export type { Snippet, ResolvedSnippet, Origin } from './data/snippet.ts';
+export type { ShaderGenerator, ResolvedStatement, BinaryOperator, ShaderGeneratorClass, FunctionDefinitionOptions, ConstantDefinitionOptions, VariableDefinitionOptions, } from './tgsl/shaderGenerator.ts';

package/internal.js

@@ -0,0 +1,12 @@
+// Each export here is available as a member on the 'typegpu/~internal' import.
+export { abstractInt, abstractFloat } from "./data/numeric.js";
+export { makeResolvable } from "./tgsl/makeResolvable.js";
+export { makeDereferenceable } from "./tgsl/makeDereferenceable.js";
+export { UnknownData } from "./data/dataTypes.js";
+export { getName, setName } from "./shared/meta.js";
+export { WgslGenerator } from "./tgsl/wgslGenerator.js";
+export { snip, withValue, withDataType, withSideEffects } from "./data/snippet.js";
+export { stringifyNode } from "./shared/tseynit.js";
+export { dualImpl } from "./core/function/dualImpl.js";
+export { isNonTransferableResource, isTransferableResource, restoreResource, snapshotResource, } from "./serial/registry.js";
+export { deserializeDataSchema, serializeDataSchema, } from "./serial/schema.js";

package/mathUtils.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @param value
+ * @param modulo has to be power of 2
+ */
+export declare const roundUp: (value: number, modulo: number) => number;

package/mathUtils.js

@@ -1,13 +1,9 @@
-//#region src/mathUtils.ts
 /**
-* @param value
-* @param modulo has to be power of 2
-*/
-const roundUp = (value, modulo) => {
-	const bitMask = modulo - 1;
-	const invBitMask = ~bitMask;
-	return (value & bitMask) === 0 ? value : (value & invBitMask) + modulo;
+ * @param value
+ * @param modulo has to be power of 2
+ */
+export const roundUp = (value, modulo) => {
+    const bitMask = modulo - 1;
+    const invBitMask = ~bitMask;
+    return (value & bitMask) === 0 ? value : (value & invBitMask) + modulo;
 };
-
-//#endregion
-export { roundUp };

package/memo.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Caches results of the function passed in as
+ * the argument to the constructor.
+ *
+ * If the key can be garbage collected, it will be.
+ */
+export declare class WeakMemo<TKey extends object, TValue, TArgs extends unknown[]> {
+    #private;
+    constructor(make: (key: TKey, ...args: TArgs) => TValue);
+    getOrMake(key: TKey, ...args: TArgs): TValue;
+}

package/memo.js

@@ -1,23 +1,21 @@
-//#region src/memo.ts
 /**
-* Caches results of the function passed in as
-* the argument to the constructor.
-*
-* If the key can be garbage collected, it will be.
-*/
-var WeakMemo = class {
-	#map = /* @__PURE__ */ new WeakMap();
-	#make;
-	constructor(make) {
-		this.#make = make;
-	}
-	getOrMake(key, ...args) {
-		if (this.#map.has(key)) return this.#map.get(key);
-		const value = this.#make(key, ...args);
-		this.#map.set(key, value);
-		return value;
-	}
-};
-
-//#endregion
-export { WeakMemo };
+ * Caches results of the function passed in as
+ * the argument to the constructor.
+ *
+ * If the key can be garbage collected, it will be.
+ */
+export class WeakMemo {
+    #map = new WeakMap();
+    #make;
+    constructor(make) {
+        this.#make = make;
+    }
+    getOrMake(key, ...args) {
+        if (this.#map.has(key)) {
+            return this.#map.get(key);
+        }
+        const value = this.#make(key, ...args);
+        this.#map.set(key, value);
+        return value;
+    }
+}

package/minify.d.ts

@@ -0,0 +1,5 @@
+/**
+ * This function accepts a code string, and returns equivalent code
+ * with comments and unnecessary whitespace removed.
+ */
+export declare function minify(code: string): string;

package/minify.js

@@ -0,0 +1,93 @@
+import { blankSpaces, lineBreaks } from "./core/whitespaces.js";
+import { invariant } from "./errors.js";
+/**
+ * We don't separate every WGSL token, for example `main()` already has no spaces, no need to further split it.
+ */
+const splitRegex = new RegExp(`[${[...blankSpaces].join('')}]+`, 'ug');
+/**
+ * Regex for detecting boundary characters that indicate whitespace may be needed between tokens.
+ * @example
+ * "let", "variable" // "t" and "v" both match, a space is needed
+ * "return" "a" // "n" and "a" both match, a space is needed
+ * "return" "(a+b)" // "n" matches and "(" does not, no space is needed
+ */
+const separatorNeededRegex = /[.\p{XID_Continue}]/u;
+/**
+ * This function accepts a code string, and returns equivalent code
+ * with comments and unnecessary whitespace removed.
+ */
+export function minify(code) {
+    const codeWithoutComments = stripWGSLComments(code);
+    const tokens = codeWithoutComments.split(splitRegex).filter((token) => token !== '');
+    let result = '';
+    for (let i = 0; i < tokens.length; i++) {
+        const current = tokens[i];
+        const next = tokens[i + 1];
+        invariant(current);
+        result += current;
+        if (isSpaceRequired(current, next)) {
+            result += ' ';
+        }
+    }
+    return result;
+}
+function isSpaceRequired(current, next) {
+    if (next === undefined) {
+        return false;
+    }
+    const currentLast = current.at(-1);
+    const nextFirst = next.at(0);
+    invariant(currentLast?.length === 1 && nextFirst?.length === 1, `Expected tokens during minification to not be empty.`);
+    if (separatorNeededRegex.test(currentLast) && separatorNeededRegex.test(nextFirst)) {
+        return true;
+    }
+    if (['//', '/*', '*/'].includes(`${currentLast}${nextFirst}`)) {
+        return true;
+    }
+    return false;
+}
+// Based on tint implementation.
+function stripWGSLComments(code) {
+    let result = '';
+    let copiedUpTo = 0;
+    let offset = 0;
+    while (offset < code.length) {
+        if (code.startsWith('//', offset)) {
+            result += `${code.slice(copiedUpTo, offset)} `;
+            offset += 2;
+            while (offset < code.length && !lineBreaks.has(code.charAt(offset))) {
+                offset += 1;
+            }
+            copiedUpTo = offset;
+            continue;
+        }
+        if (code.startsWith('/*', offset)) {
+            result += `${code.slice(copiedUpTo, offset)} `;
+            let depth = 1;
+            offset += 2;
+            while (offset < code.length && depth > 0) {
+                if (code.startsWith('/*', offset)) {
+                    depth += 1;
+                    offset += 2;
+                }
+                else if (code.startsWith('*/', offset)) {
+                    depth -= 1;
+                    offset += 2;
+                }
+                else {
+                    offset += 1;
+                }
+            }
+            if (depth > 0) {
+                throw new SyntaxError(`Block comment opening without corresponding closing found during minification.`);
+            }
+            copiedUpTo = offset;
+            continue;
+        }
+        if (code.startsWith('*/', offset)) {
+            throw new SyntaxError(`Block comment closing without corresponding opening found during minification.`);
+        }
+        offset += 1;
+    }
+    return result + code.slice(copiedUpTo);
+}

package/nameUtils.d.ts

@@ -0,0 +1,29 @@
+export declare const bannedTokens: Set<string>;
+export declare const builtins: Set<string>;
+/**
+ * Sanitizes the primer so that it is compliant with WGSL guidelines.
+ * This primer is not necessarily a valid identifier yet, as it may still collide with other idents or reserved keywords.
+ */
+export declare function sanitizePrimer(primer: string | undefined): string;
+type ValidationResult = {
+    success: true;
+    error?: undefined;
+} | {
+    success: false;
+    error?: string | undefined;
+};
+/**
+ * A function for checking whether an identifier is valid.
+ * If `ident` passes the checks, it is not necessarily a valid identifier yet, as it may still collide with other idents or reserved keywords.
+ * @example
+ * validateIdentifier("ident"); // { success: true }
+ * validateIdentifier("_"); // { success: false, error: `Identifiers cannot be equal to '' or '_'` }
+ * validateIdentifier("my variable"); // { success: false, error: "Identifiers cannot contain whitespace." }
+ * validateIdentifier("0"); // { success: false, error: "Identifier is not compliant with the WGSL guideline." }
+ */
+export declare function validateIdentifier(ident: string): ValidationResult;
+/**
+ * Same as `validateIdentifier`, except also checks for bannedToken clashes.
+ */
+export declare function validateProp(ident: string): ValidationResult;
+export {};