@bigmistqke/view.gl 0.1.2 → 0.1.4

package/dist/{types-DoFAJoh-.d.mts → types-CGTxl3Eq.d.mts}

@@ -1,10 +1,24 @@
-type Merge<A, B> = {
-    [K in keyof A | keyof B]: K extends keyof A ? K extends keyof B ? A[K] | B[K] : A[K] : K extends keyof B ? B[K] : never;
-};
 type Prettify<T> = {
     [K in keyof T]: T[K];
 } & {};
 type GL = WebGLRenderingContext | WebGL2RenderingContext;
+type DeepMerge<A extends readonly [...any]> = A extends [infer L, ...infer R] ? DeepMergeTwo<L, DeepMerge<R>> : unknown;
+type DeepMergeTwo<TBase, TOverride> = {
+    [K in keyof TBase | keyof TOverride]: K extends keyof TOverride ? K extends keyof TBase ? ShallowMerge<[TBase[K], TOverride[K]]> : TOverride[K] : K extends keyof TBase ? TBase[K] : never;
+};
+type ShallowMerge<A extends readonly [...any]> = A extends [infer L, ...infer R] ? ShallowMergeTwo<L, ShallowMerge<R>> : unknown;
+type OptionalPropertyNames<T> = {
+    [K in keyof T]-?: {} extends {
+        [P in K]: T[K];
+    } ? K : never;
+}[keyof T];
+type SpreadProperties<L, R, K extends keyof L & keyof R> = {
+    [P in K]: L[P] | Exclude<R[P], undefined>;
+};
+type Id<T> = T extends infer U ? {
+    [K in keyof U]: U[K];
+} : never;
+type ShallowMergeTwo<L, R> = Id<Pick<L, Exclude<keyof L, keyof R>> & Pick<R, Exclude<keyof R, OptionalPropertyNames<R>>> & Pick<R, Exclude<OptionalPropertyNames<R>, keyof L>> & SpreadProperties<L, R, OptionalPropertyNames<R> & keyof L>>;
 /**********************************************************************************/
 /**********************************************************************************/
 type GLTarget = 'ARRAY_BUFFER' | 'ELEMENT_ARRAY_BUFFER';
@@ -219,19 +233,23 @@ interface ViewSchema {
     interleavedAttributes?: InterleavedAttributeSchema;
     buffers?: BufferSchema;
 }
+interface ViewSchemaPartial {
+    uniforms?: Record<string | symbol, Partial<UniformOptions>>;
+    attributes?: Record<string | symbol, Partial<AttributeOptions>>;
+    interleavedAttributes?: Record<string | symbol, Partial<InterleavedAttributeOptions>>;
+    buffers?: Record<string | symbol, Partial<BufferOptions>>;
+}
 type View<T extends ViewSchema = ViewSchema> = {
     attributes: T['attributes'] extends AttributeSchema ? AttributeView<T['attributes']> : undefined;
     interleavedAttributes: T['interleavedAttributes'] extends InterleavedAttributeSchema ? InterleavedAttributeView<T['interleavedAttributes']> : undefined;
     buffers: T['buffers'] extends BufferSchema ? BufferView<T['buffers']> : undefined;
     uniforms: T['uniforms'] extends UniformSchema ? UniformView<T['uniforms']> : never;
 };
-/**********************************************************************************/
-/**********************************************************************************/
-interface GLSL {
-    template: string;
-    uniforms: Record<string | symbol, UniformOptions>;
-    attributes: Record<string | symbol, AttributeOptions>;
-    interleavedAttributes: Record<string | symbol, InterleavedAttributeOptions>;
+type GLSLSlot = GLSLTag | UniformTag | AttributeTag | InterleaveTag | string | number | symbol;
+interface GLSLTag<TSlots extends GLSLSlot[] = GLSLSlot[]> {
+    type: 'glsl';
+    template: TemplateStringsArray;
+    slots: TSlots;
 }
 type UniformTag<TKey extends string | symbol = string | symbol, TKind extends UniformKind = UniformKind, TOptions extends Partial<UniformOptions> = UniformOptions> = TOptions extends {
     size: infer TSize;
@@ -245,6 +263,10 @@ type UniformTag<TKey extends string | symbol = string | symbol, TKind extends Un
     kind: TKind;
     key: TKey;
 };
+interface UniformTagFn<TKind extends UniformKind> {
+    <const TKey extends string | symbol, const TOptions extends Omit<UniformOptions, 'kind'>>(key: TKey, TOptions: TOptions): Prettify<UniformTag<TKey, TKind, TOptions>>;
+    <const TName extends string | symbol>(key: TName): Prettify<UniformTag<TName, TKind>>;
+}
 interface AttributeTag<TKey extends string | symbol = string | symbol, TKind extends AttributeKind = AttributeKind, TInstanced extends boolean | undefined = boolean | undefined> {
     type: 'attribute';
     kind: TKind;
@@ -263,4 +285,4 @@ type InterleaveTag<TKey extends string | symbol = string | symbol, TLayout exten
     };
 };
 
-export type { AttributeSchema as A, BufferSchema as B, GL as G, InterleavedAttributeSchema as I, Merge as M, Prettify as P, UniformSchema as U, ViewSchema as V, ViewOptions as a, View as b, UniformView as c, AttributeView as d, InterleavedAttributeView as e, BufferView as f, UniformKind as g, UniformOptions as h, UniformTag as i, AttributeTagFn as j, AttributeTag as k, AttributeKind as l, AttributeOptions as m, InterleaveTag as n, GLSL as o };
+export type { AttributeSchema as A, BufferSchema as B, DeepMerge as D, GL as G, InterleavedAttributeSchema as I, Prettify as P, ShallowMerge as S, UniformSchema as U, ViewSchema as V, ViewOptions as a, View as b, UniformView as c, AttributeView as d, InterleavedAttributeView as e, BufferView as f, GLSLSlot as g, GLSLTag as h, UniformTagFn as i, AttributeTagFn as j, AttributeTag as k, AttributeKind as l, AttributeOptions as m, InterleaveTag as n, ViewSchemaPartial as o, UniformTag as p };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bigmistqke/view.gl",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "🪟 Utilities for managing WebGL resources.",
   "exports": {
     ".": {
@@ -38,6 +38,7 @@
     "prepublish": "pnpm build",
     "test": "vitest --run",
     "test:coverage": "vitest run --coverage",
-    "test:ui": "vitest --ui"
+    "test:ui": "vitest --ui",
+    "lint:types": "tsc --noEmit"
   }
 }

package/src/index.ts

@@ -52,12 +52,12 @@ export function toID(key: string | number | symbol) {
 /*                                                                                */
 /**********************************************************************************/
 
-export function view<T extends ViewSchema>(
+export function view<TSchema extends ViewSchema>(
   gl: GL,
   program: WebGLProgram,
-  schema: T,
+  schema: TSchema,
   options?: ViewOptions,
-): View<T> {
+): View<TSchema> {
   return {
     uniforms: !schema.uniforms ? undefined : uniformView(gl, program, schema.uniforms),
     attributes: !schema.attributes
@@ -67,7 +67,7 @@ export function view<T extends ViewSchema>(
       ? undefined
       : interleavedAttributeView(gl, program, schema.interleavedAttributes, options),
     buffers: !schema.buffers ? undefined : bufferView(gl, schema.buffers),
-  } as View<T>
+  } as View<TSchema>
 }
 
 /**********************************************************************************/

package/src/tag.ts

@@ -1,36 +1,35 @@
-import { toID } from '.'
+import { toID, view } from '.'
 import type {
   AttributeKind,
   AttributeOptions,
   AttributeTag,
-  AttributeTagFn,
-  GLSL,
+  AttributeTagFn as AttributeTagMethod,
+  DeepMerge,
+  GLSLSlot,
+  GLSLTag,
   InterleaveTag,
-  Merge,
   Prettify,
+  ShallowMerge,
   UniformKind,
   UniformOptions,
   UniformTag,
+  UniformTagFn as UniformTagMethod,
+  View,
+  ViewSchema,
+  ViewSchemaPartial,
 } from './types'
 import { createProgram } from './utils'
 
-/**********************************************************************************/
-/*                                                                                */
-/*                                  Tag Utilities                                 */
-/*                                                                                */
-/**********************************************************************************/
-
-interface UniformTagFn<TKind extends UniformKind> {
-  <const TKey extends string | symbol, const TOptions extends Omit<UniformOptions, 'kind'>>(
-    key: TKey,
-    TOptions: TOptions,
-  ): Prettify<UniformTag<TKey, TKind, TOptions>>
-  <const TName extends string | symbol>(key: TName): Prettify<UniformTag<TName, TKind>>
+export function glsl<TSlot extends GLSLSlot, TSlots extends TSlot[]>(
+  template: TemplateStringsArray,
+  ...slots: [...TSlots]
+): GLSLTag<TSlots> {
+  return { template, slots, type: 'glsl' }
 }
 
 export const uniform = new Proxy(
   {} as {
-    [TKey in UniformKind]: UniformTagFn<TKey>
+    [TKey in UniformKind]: UniformTagMethod<TKey>
   },
   {
     get(target, property) {
@@ -48,7 +47,7 @@ export const uniform = new Proxy(
 
 export const attribute = new Proxy(
   {} as {
-    [TKey in AttributeKind]: AttributeTagFn<TKey>
+    [TKey in AttributeKind]: AttributeTagMethod<TKey>
   },
   {
     get(target, property) {
@@ -93,109 +92,205 @@ export function interleave<
 
 /**********************************************************************************/
 /*                                                                                */
-/*                                       GLSL                                     */
+/*                                     Compile                                    */
 /*                                                                                */
 /**********************************************************************************/
 
-export function glsl<
-  Elem extends string,
-  Template extends ReadonlyArray<Elem>,
-  Hole extends UniformTag | AttributeTag | InterleaveTag | string | number | symbol,
-  Holes extends Hole[],
->([initial, ...rest]: Template, ...holes: [...Holes]) {
-  const v300 = initial?.startsWith('#version 300 es')
-
-  const template = rest.reduce((out, templatePart, index) => {
-    const hole = holes[index]
-    const holePart =
-      typeof hole === 'string' || typeof hole === 'number' || typeof hole === 'symbol'
-        ? toID(hole)
-        : hole.type === 'interleavedAttribute'
-          ? hole.layout.reduce(
-              (a, v) =>
-                v300
-                  ? `${a}in ${v.kind} ${toID(v.key)};\n`
-                  : `${a}attribute ${v.kind} ${toID(v.key)};\n`,
-              '',
-            )
-          : typeof hole === 'object' && hole.type === 'uniform' && 'size' in hole
-            ? `${hole.type} ${hole.kind} ${toID(hole.key)}[${hole.size}];`
-            : `${hole.type === 'attribute' && v300 ? 'in' : hole.type} ${hole.kind} ${toID(hole.key)};`
-    return out + holePart + templatePart
-  }, initial || '')
-
-  return holes.reduce(
-    (resources, resource) => {
-      if (
-        typeof resource === 'string' ||
-        typeof resource === 'number' ||
-        typeof resource === 'symbol'
-      ) {
-        return resources
+type glslTagToSchema<TTag extends GLSLTag> =
+  FlattenSlots<TTag> extends infer TSlots
+    ? TSlots extends Array<any>
+      ? GLSLSlotsToSchema<TSlots>
+      : never
+    : never
+
+type GLSLSlotsToSchema<TSlots extends Array<GLSLSlot>> = {
+  uniforms: {
+    [K in Extract<TSlots[number], UniformTag> as K['key']]: Prettify<Omit<K, 'name' | 'type'>>
+  }
+  attributes: {
+    [K in Extract<TSlots[number], AttributeTag> as K['key']]: Prettify<Omit<K, 'name' | 'type'>>
+  }
+  interleavedAttributes: {
+    [K in Extract<TSlots[number], InterleaveTag> as K['key']]: Prettify<Omit<K, 'name' | 'type'>>
+  }
+}
+
+type FlattenSlots<T> =
+  T extends GLSLTag<infer TSlots>
+    ? _FlattenSlots<TSlots>
+    : T extends Array<GLSLSlot>
+      ? _FlattenSlots<T>
+      : never
+
+type _FlattenSlots<T extends Array<GLSLSlot>> = T extends [infer First, ...infer Rest]
+  ? First extends GLSLTag
+    ? [...FlattenSlots<First>, ...FlattenSlots<Rest>]
+    : First extends unknown[]
+      ? [...FlattenSlots<First>, ...FlattenSlots<Rest>]
+      : [First, ...FlattenSlots<Rest>]
+  : []
+
+type MergeGLSLSchema<
+  TVertex extends ViewSchema,
+  TFragment extends ViewSchema,
+  TOverrides extends ViewSchemaPartial,
+> = {
+  uniforms: DeepMerge<
+    [ShallowMerge<[TVertex['uniforms'], TFragment['uniforms']]>, TOverrides['uniforms']]
+  >
+  attributes: DeepMerge<
+    [ShallowMerge<[TVertex['attributes'], TFragment['attributes']]>, TOverrides['attributes']]
+  >
+  interleavedAttributes: DeepMerge<
+    [
+      ShallowMerge<[TVertex['interleavedAttributes'], TFragment['interleavedAttributes']]>,
+      TOverrides['interleavedAttributes'],
+    ]
+  >
+}
+
+type CompileResult<
+  TVertex extends GLSLTag,
+  TFragment extends GLSLTag,
+  TOverrides extends ViewSchemaPartial,
+> =
+  MergeGLSLSchema<
+    glslTagToSchema<TVertex>,
+    glslTagToSchema<TFragment>,
+    TOverrides
+  > extends infer TSchema extends ViewSchema
+    ? {
+        program: WebGLProgram
+        schema: TSchema
+        view: View<TSchema>
       }
-      // @ts-expect-error
-      const { key: name, type, ...rest } = resource
-      // @ts-expect-error
-      resources[`${type}s`][name] = rest
-      return resources
+    : never
+
+export function compile<
+  TVertex extends GLSLTag,
+  TFragment extends GLSLTag,
+  TOverride extends ViewSchemaPartial,
+>(gl: WebGLRenderingContext, vertex: TVertex, fragment: TFragment, overrideSchema?: TOverride) {
+  const _vertex = resolveGLSLTag(vertex)
+  const _fragment = resolveGLSLTag(fragment)
+
+  const schema = {
+    uniforms: {
+      ..._vertex.schema.uniforms,
+      ..._fragment.schema.uniforms,
     },
-    {
-      template,
-      uniforms: {},
-      attributes: {},
-      interleavedAttributes: {},
-    } as {
-      template: string
-      uniforms: {
-        [K in Extract<Holes[number], UniformTag> as K['key']]: Prettify<Omit<K, 'name' | 'type'>>
-      }
-      attributes: {
-        [K in Extract<Holes[number], AttributeTag> as K['key']]: Prettify<Omit<K, 'name' | 'type'>>
-      }
-      interleavedAttributes: {
-        [K in Extract<Holes[number], InterleaveTag> as K['key']]: Prettify<Omit<K, 'name' | 'type'>>
-      }
+    attributes: {
+      ..._vertex.schema.attributes,
+      ..._fragment.schema.attributes,
     },
-  )
-}
+    interleavedAttributes: {
+      ..._vertex.schema.interleavedAttributes,
+      ..._fragment.schema.interleavedAttributes,
+    },
+  }
 
-/**********************************************************************************/
-/*                                                                                */
-/*                                     Compile                                    */
-/*                                                                                */
-/**********************************************************************************/
+  for (const kind in overrideSchema) {
+    const schemaKind = schema[kind as keyof typeof schema]
+    const overrideSchemaKind = overrideSchema[kind]
+
+    for (const key in overrideSchemaKind) {
+      // @ts-expect-error
+      schemaKind[key] = {
+        // @ts-expect-error
+        ...schemaKind[key],
+        ...overrideSchemaKind[key],
+      }
+    }
+  }
 
-export function compile<TVertex extends GLSL, TFragment extends GLSL>(
-  gl: WebGLRenderingContext,
-  vertex: TVertex,
-  fragment: TFragment,
-) {
-  const program = createProgram(gl, vertex.template, fragment.template)
+  const program = createProgram(gl, _vertex.template, _fragment.template)
 
   return {
     program,
-    schema: {
-      uniforms: {
-        ...vertex.uniforms,
-        ...fragment.uniforms,
-      },
-      attributes: {
-        ...vertex.attributes,
-        ...fragment.attributes,
-      },
-      interleavedAttributes: {
-        ...vertex.interleavedAttributes,
-        ...fragment.interleavedAttributes,
-      },
-    },
-  } as {
-    program: WebGLProgram
-    schema: {
-      uniforms: Prettify<Merge<TVertex['uniforms'], TFragment['uniforms']>>
-      attributes: Prettify<Merge<TVertex['attributes'], TFragment['attributes']>>
-      interleavedAttributes: Prettify<
-        Merge<TVertex['interleavedAttributes'], TFragment['interleavedAttributes']>
-      >
+    schema,
+    view: view(gl, program, schema),
+  } as CompileResult<TVertex, TFragment, TOverride>
+}
+
+function resolveGLSLTag<TTag extends GLSLTag>(tag: TTag) {
+  return {
+    template: glslTagToString(tag),
+    schema: glslTagToSchema(tag),
+  }
+}
+
+function glslTagToSchema<TTag extends GLSLTag>(tag: TTag) {
+  const result = {
+    uniforms: {},
+    attributes: {},
+    interleavedAttributes: {},
+  }
+
+  for (const slot of tag.slots) {
+    if (typeof slot !== 'object') {
+      continue
     }
+
+    if (slot.type === 'glsl') {
+      const { uniforms, attributes, interleavedAttributes } = glslTagToSchema(slot)
+
+      result.uniforms = {
+        ...result.uniforms,
+        ...uniforms,
+      }
+      result.attributes = {
+        ...result.attributes,
+        ...attributes,
+      }
+      result.interleavedAttributes = {
+        ...result.interleavedAttributes,
+        ...interleavedAttributes,
+      }
+
+      continue
+    }
+
+    const { key: name, type, ...rest } = slot
+
+    // @ts-expect-error
+    result[`${type}s`][name] = rest
   }
+
+  return result
+}
+
+function glslTagToString<TTag extends GLSLTag>({ template: [initial, ...rest], slots }: TTag) {
+  const v300 = !!initial?.startsWith('#version 300 es')
+
+  let template = initial ?? ''
+
+  for (let i = 0; i < rest.length; i++) {
+    template += `${glslSlotToString(slots[i]!, v300)}${rest[i]}`
+  }
+
+  return template
+}
+
+function glslSlotToString(slot: GLSLSlot, v300: boolean) {
+  if (typeof slot !== 'object') {
+    return toID(slot)
+  }
+
+  if (slot.type === 'glsl') {
+    return glslTagToString(slot)
+  }
+
+  if (slot.type === 'interleavedAttribute') {
+    return slot.layout.reduce(
+      (a, v) =>
+        v300 ? `${a}in ${v.kind} ${toID(v.key)};\n` : `${a}attribute ${v.kind} ${toID(v.key)};\n`,
+      '',
+    )
+  }
+
+  if (slot.type === 'uniform' && 'size' in slot) {
+    return `${slot.type} ${slot.kind} ${toID(slot.key)}[${slot.size}];`
+  }
+
+  return `${slot.type === 'attribute' && v300 ? 'in' : slot.type} ${slot.kind} ${toID(slot.key)};`
 }

package/src/types.ts

@@ -18,6 +18,42 @@ export type RemoveSuffix<T, S extends string> = {
 
 export type GL = WebGLRenderingContext | WebGL2RenderingContext
 
+export type DeepMerge<A extends readonly [...any]> = A extends [infer L, ...infer R]
+  ? DeepMergeTwo<L, DeepMerge<R>>
+  : unknown
+
+type DeepMergeTwo<TBase, TOverride> = {
+  [K in keyof TBase | keyof TOverride]: K extends keyof TOverride
+    ? K extends keyof TBase
+      ? ShallowMerge<[TBase[K], TOverride[K]]>
+      : TOverride[K]
+    : K extends keyof TBase
+      ? TBase[K]
+      : never
+}
+
+// see https://stackoverflow.com/a/49683575
+export type ShallowMerge<A extends readonly [...any]> = A extends [infer L, ...infer R]
+  ? ShallowMergeTwo<L, ShallowMerge<R>>
+  : unknown
+
+type OptionalPropertyNames<T> = {
+  [K in keyof T]-?: {} extends { [P in K]: T[K] } ? K : never
+}[keyof T]
+
+type SpreadProperties<L, R, K extends keyof L & keyof R> = {
+  [P in K]: L[P] | Exclude<R[P], undefined>
+}
+
+type Id<T> = T extends infer U ? { [K in keyof U]: U[K] } : never
+
+type ShallowMergeTwo<L, R> = Id<
+  Pick<L, Exclude<keyof L, keyof R>> &
+    Pick<R, Exclude<keyof R, OptionalPropertyNames<R>>> &
+    Pick<R, Exclude<OptionalPropertyNames<R>, keyof L>> &
+    SpreadProperties<L, R, OptionalPropertyNames<R> & keyof L>
+>
+
 /**********************************************************************************/
 /*                                                                                */
 /*                                    Constants                                   */
@@ -359,6 +395,7 @@ export interface UniformOptions {
 }
 
 export type UniformSchema = Record<string | symbol, UniformOptions>
+export type UniformSchemaPartial = Record<string | symbol, Partial<UniformOptions>>
 
 export type UniformMethods<TOptions extends UniformOptions> = TOptions['size'] extends number
   ? {
@@ -645,6 +682,13 @@ export interface ViewSchema {
   buffers?: BufferSchema
 }
 
+export interface ViewSchemaPartial {
+  uniforms?: Record<string | symbol, Partial<UniformOptions>>
+  attributes?: Record<string | symbol, Partial<AttributeOptions>>
+  interleavedAttributes?: Record<string | symbol, Partial<InterleavedAttributeOptions>>
+  buffers?: Record<string | symbol, Partial<BufferOptions>>
+}
+
 export type View<T extends ViewSchema = ViewSchema> = {
   attributes: T['attributes'] extends AttributeSchema ? AttributeView<T['attributes']> : undefined
   interleavedAttributes: T['interleavedAttributes'] extends InterleavedAttributeSchema
@@ -660,11 +704,24 @@ export type View<T extends ViewSchema = ViewSchema> = {
 /*                                                                                */
 /**********************************************************************************/
 
-export interface GLSL {
-  template: string
-  uniforms: Record<string | symbol, UniformOptions>
-  attributes: Record<string | symbol, AttributeOptions>
-  interleavedAttributes: Record<string | symbol, InterleavedAttributeOptions>
+export interface GLSLResult {
+  program: WebGLProgram
+  schema: ViewSchema
+}
+
+export type GLSLSlot =
+  | GLSLTag
+  | UniformTag
+  | AttributeTag
+  | InterleaveTag
+  | string
+  | number
+  | symbol
+
+export interface GLSLTag<TSlots extends GLSLSlot[] = GLSLSlot[]> {
+  type: 'glsl'
+  template: TemplateStringsArray
+  slots: TSlots
 }
 
 export type UniformTag<
@@ -684,6 +741,14 @@ export type UniformTag<
       key: TKey
     }
 
+export interface UniformTagFn<TKind extends UniformKind> {
+  <const TKey extends string | symbol, const TOptions extends Omit<UniformOptions, 'kind'>>(
+    key: TKey,
+    TOptions: TOptions,
+  ): Prettify<UniformTag<TKey, TKind, TOptions>>
+  <const TName extends string | symbol>(key: TName): Prettify<UniformTag<TName, TKind>>
+}
+
 export interface AttributeTag<
   TKey extends string | symbol = string | symbol,
   TKind extends AttributeKind = AttributeKind,

package/src/utils/index.ts

@@ -71,26 +71,26 @@ export const kindToUniformFnName = <T extends UniformKind>(
   switch (kind[0]) {
     // mat
     case 'm':
-      return 'Matrix' + kind.slice(3) + 'fv'
+      return ('Matrix' + kind.slice(3) + 'fv') as KIND_TO_UNIFORM_FN_NAME_MAP[T]
     // sampler/booleans/integer
     case 's':
     case 'b':
     case 'i':
-      return (kind.match(/\d/)?.[0] ?? '1') + 'i'
+      return ((kind.match(/\d/)?.[0] ?? '1') + 'i') as KIND_TO_UNIFORM_FN_NAME_MAP[T]
     // unsigned integers
     case 'u':
-      return (kind[4] || '1') + 'ui'
+      return ((kind[4] || '1') + 'ui') as KIND_TO_UNIFORM_FN_NAME_MAP[T]
     // vec
     case 'v':
-      return kind[3] + 'f'
+      return (kind[3] + 'f') as KIND_TO_UNIFORM_FN_NAME_MAP[T]
     default:
       switch (kind) {
         case 'float':
-          return '1f'
+          return '1f' as KIND_TO_UNIFORM_FN_NAME_MAP[T]
         case 'uint':
-          return '1ui'
+          return '1ui' as KIND_TO_UNIFORM_FN_NAME_MAP[T]
         default:
-          return '1i'
+          return '1i' as KIND_TO_UNIFORM_FN_NAME_MAP[T]
       }
   }
 }
@@ -167,7 +167,7 @@ export function createTexture(
     if (!(name in gl)) {
       throw new Error(`Attempted to create webgl2-only texture (${name}) in webgl1`)
     }
-    return gl[name]
+    return gl[name as keyof typeof gl] as any
   }
 
   gl.bindTexture(gl[target], texture)
@@ -268,7 +268,7 @@ export function createFramebuffer(gl: GL, { attachment, texture, ...options }: F
 /*                                                                                */
 /**********************************************************************************/
 
-type UpsertMapKind<T, U> = Map<T, U> | WeakMap<T, U>
+type UpsertMapKind<T, U> = Map<T, U> | (T extends WeakKey ? WeakMap<T, U> : never)
 
 export function createUpsertMap<T extends UpsertMapKind<any, any> = Map<any, any>>(
   constructor?: new () => T,