chore: Remove the deprecated asUsage api

packages/typegpu/src/core/buffer/buffer.ts

@@ -26,13 +26,13 @@ import type {
 import { isGPUBuffer } from '../../types.ts';
 import type { ExperimentalTgpuRoot } from '../root/rootTypes.ts';
 import {
-  asMutable,
-  asReadonly,
-  asUniform,
+  mutable,
+  readonly,
   type TgpuBufferMutable,
   type TgpuBufferReadonly,
   type TgpuBufferUniform,
   type TgpuFixedBufferUsage,
+  uniform,
 } from './bufferUsage.ts';
 
 // ----------
@@ -79,11 +79,7 @@ type UsageTypeToBufferUsage<TData extends BaseData> = {
   readonly: TgpuBufferReadonly<TData> & TgpuFixedBufferUsage<TData>;
 };
 
-const usageToUsageConstructor = {
-  uniform: asUniform,
-  mutable: asMutable,
-  readonly: asReadonly,
-};
+const usageToUsageConstructor = { uniform, mutable, readonly };
 
 /**
  * Done as an object to later Prettify it

packages/typegpu/src/core/buffer/bufferUsage.ts

@@ -308,15 +308,12 @@ const mutableUsageMap = new WeakMap<
   TgpuFixedBufferImpl<AnyWgslData, 'mutable'>
 >();
 
-/**
- * @deprecated Use buffer.as('mutable') instead.
- */
-export function asMutable<TData extends AnyWgslData>(
+export function mutable<TData extends AnyWgslData>(
   buffer: TgpuBuffer<TData> & StorageFlag,
 ): TgpuBufferMutable<TData> & TgpuFixedBufferUsage<TData> {
   if (!isUsableAsStorage(buffer)) {
     throw new Error(
-      `Cannot pass ${buffer} to asMutable, as it is not allowed to be used as storage. To allow it, call .$usage('storage') when creating the buffer.`,
+      `Cannot call as('mutable') on ${buffer}, as it is not allowed to be used as storage. To allow it, call .$usage('storage') when creating the buffer.`,
     );
   }
 
@@ -335,15 +332,12 @@ const readonlyUsageMap = new WeakMap<
   TgpuFixedBufferImpl<AnyWgslData, 'readonly'>
 >();
 
-/**
- * @deprecated Use buffer.as('readonly') instead.
- */
-export function asReadonly<TData extends AnyWgslData>(
+export function readonly<TData extends AnyWgslData>(
   buffer: TgpuBuffer<TData> & StorageFlag,
 ): TgpuBufferReadonly<TData> & TgpuFixedBufferUsage<TData> {
   if (!isUsableAsStorage(buffer)) {
     throw new Error(
-      `Cannot pass ${buffer} to asReadonly, as it is not allowed to be used as storage. To allow it, call .$usage('storage') when creating the buffer.`,
+      `Cannot call as('readonly') on ${buffer}, as it is not allowed to be used as storage. To allow it, call .$usage('storage') when creating the buffer.`,
     );
   }
 
@@ -362,15 +356,12 @@ const uniformUsageMap = new WeakMap<
   TgpuFixedBufferImpl<AnyWgslData, 'uniform'>
 >();
 
-/**
- * @deprecated Use buffer.as('uniform') instead.
- */
-export function asUniform<TData extends AnyWgslData>(
+export function uniform<TData extends AnyWgslData>(
   buffer: TgpuBuffer<TData> & UniformFlag,
 ): TgpuBufferUniform<TData> & TgpuFixedBufferUsage<TData> {
   if (!isUsableAsUniform(buffer)) {
     throw new Error(
-      `Cannot pass ${buffer} to asUniform, as it is not allowed to be used as a uniform. To allow it, call .$usage('uniform') when creating the buffer.`,
+      `Cannot call as('uniform') on ${buffer}, as it is not allowed to be used as a uniform. To allow it, call .$usage('uniform') when creating the buffer.`,
     );
   }
 

packages/typegpu/tests/bufferUsage.test.ts

@@ -73,6 +73,21 @@ describe('TgpuBufferUniform', () => {
       }"
     `);
   });
+
+  it('allows creating bufferUsages only for buffers allowing them', ({ root }) => {
+    root.createBuffer(d.u32, 2).$usage('uniform').as('uniform');
+    root.createBuffer(d.u32, 2).$usage('uniform', 'storage').as('uniform');
+    root.createBuffer(d.u32, 2).$usage('uniform', 'vertex').as('uniform');
+    // @ts-expect-error
+    expect(() => root.createBuffer(d.u32, 2).as('uniform')).toThrow();
+    expect(() =>
+      root
+        .createBuffer(d.u32, 2)
+        .$usage('storage')
+        // @ts-expect-error
+        .as('uniform')
+    ).toThrow();
+  });
 });
 
 describe('TgpuBufferMutable', () => {
@@ -163,6 +178,21 @@ describe('TgpuBufferMutable', () => {
       expect(result.value).toBe(3);
     });
   });
+
+  it('allows creating bufferUsages only for buffers allowing them', ({ root }) => {
+    root.createBuffer(d.u32, 2).$usage('storage').as('mutable');
+    root.createBuffer(d.u32, 2).$usage('storage', 'uniform').as('mutable');
+    root.createBuffer(d.u32, 2).$usage('vertex', 'storage').as('mutable');
+    // @ts-expect-error
+    expect(() => root.createBuffer(d.u32, 2).as('mutable')).toThrow();
+    expect(() =>
+      root
+        .createBuffer(d.u32, 2)
+        .$usage('uniform')
+        // @ts-expect-error
+        .as('mutable')
+    ).toThrow();
+  });
 });
 
 describe('TgpuBufferReadonly', () => {
@@ -273,4 +303,19 @@ describe('TgpuBufferReadonly', () => {
       expect(result.value).toBe(123);
     });
   });
+
+  it('allows creating bufferUsages only for buffers allowing them', ({ root }) => {
+    root.createBuffer(d.u32, 2).$usage('storage').as('readonly');
+    root.createBuffer(d.u32, 2).$usage('storage', 'uniform').as('readonly');
+    root.createBuffer(d.u32, 2).$usage('storage', 'vertex').as('readonly');
+    // @ts-expect-error
+    expect(() => root.createBuffer(d.u32, 2).as('readonly')).toThrow();
+    expect(() =>
+      root
+        .createBuffer(d.u32, 2)
+        .$usage('uniform')
+        // @ts-expect-error
+        .as('readonly')
+    ).toThrow();
+  });
 });