glre 0.33.0 → 0.35.0

package/src/node/infer.ts

@@ -1,108 +1,91 @@
 import { is } from '../utils/helpers'
 import {
-        BOOL_RETURN_FUNCTIONS,
         BUILTIN_TYPES,
         COMPARISON_OPERATORS,
         COMPONENT_COUNT_TO_TYPE,
-        CONSTANTS,
-        FIRST_ARG_TYPE_FUNCTIONS,
-        HIGHEST_TYPE_FUNCTIONS,
+        FUNCTION_RETURN_TYPES,
         LOGICAL_OPERATORS,
-        PRESERVE_TYPE_FUNCTIONS,
-        SCALAR_RETURN_FUNCTIONS,
-        VEC3_RETURN_FUNCTIONS,
-        VEC4_RETURN_FUNCTIONS,
 } from './const'
 import { isConstants, isNodeProxy, isSwizzle } from './utils'
-import type { Constants, NodeContext, NodeProxy, X } from './types'
+import type { Constants as C, NodeContext, NodeProxy, X } from './types'
 
-const getHighestPriorityType = (args: X[], c: NodeContext) => {
-        return args.reduce((highest, current) => {
-                const currentType = infer(current, c)
-                const highestPriority = CONSTANTS.indexOf(highest as any)
-                const currentPriority = CONSTANTS.indexOf(currentType as any)
-                return currentPriority > highestPriority ? currentType : highest
-        }, 'float') as Constants
+const inferBuiltin = <T extends C>(id: string | undefined) => {
+        return BUILTIN_TYPES[id as keyof typeof BUILTIN_TYPES] as T
 }
 
-const inferBuiltin = (id: string | undefined): Constants => {
-        return BUILTIN_TYPES[id as keyof typeof BUILTIN_TYPES]!
+// Unified logic with types.ts InferOperator type
+const inferOperator = <T extends C>(L: T, R: T, op: string): T => {
+        if (COMPARISON_OPERATORS.includes(op as any) || LOGICAL_OPERATORS.includes(op as any)) return 'bool' as T
+        if (L === R) return L
+        // broadcast
+        if (L === 'float' || L === 'int') return R
+        if (R === 'float' || R === 'int') return L
+        // mat * vec → vec
+        if (L === 'mat4' && R === 'vec4') return R
+        if (L === 'mat3' && R === 'vec3') return R
+        if (L === 'mat2' && R === 'vec2') return R
+        // vec * mat → vec
+        if (L === 'vec4' && R === 'mat4') return L
+        if (L === 'vec3' && R === 'mat3') return L
+        if (L === 'vec2' && R === 'mat2') return L
+        return L
 }
 
-const inferFunction = (funcName: string, args: X[], c: NodeContext): Constants => {
-        const firstArgType = args.length > 0 ? infer(args[0], c) : 'float'
-        if (FIRST_ARG_TYPE_FUNCTIONS.includes(funcName as any)) return firstArgType
-        if (SCALAR_RETURN_FUNCTIONS.includes(funcName as any)) return 'float'
-        if (BOOL_RETURN_FUNCTIONS.includes(funcName as any)) return 'bool'
-        if (PRESERVE_TYPE_FUNCTIONS.includes(funcName as any)) return firstArgType
-        if (VEC3_RETURN_FUNCTIONS.includes(funcName as any)) return 'vec3'
-        if (VEC4_RETURN_FUNCTIONS.includes(funcName as any)) return 'vec4'
-        if (HIGHEST_TYPE_FUNCTIONS.includes(funcName as any)) return getHighestPriorityType(args, c)
-        return firstArgType
+export const inferPrimitiveType = <T extends C>(x: X) => {
+        if (is.bol(x)) return 'bool' as T
+        if (is.str(x)) return 'texture' as T
+        if (is.num(x)) return 'float' as T // @TODO FIX:  Number.isInteger(x) ? 'int' : 'float'
+        if (is.arr(x)) return COMPONENT_COUNT_TO_TYPE[x.length as keyof typeof COMPONENT_COUNT_TO_TYPE] as T
+        return 'float' as T
 }
 
-const inferOperator = (leftType: string, rightType: string, op: string): Constants => {
-        if (COMPARISON_OPERATORS.includes(op as any)) return 'bool'
-        if (LOGICAL_OPERATORS.includes(op as any)) return 'bool'
-        if (leftType === rightType) return leftType as Constants
-        if (leftType.includes('vec') && !rightType.includes('vec')) return leftType as Constants
-        if (rightType.includes('vec') && !leftType.includes('vec')) return rightType as Constants
-        const leftPriority = CONSTANTS.indexOf(leftType as any)
-        const rightPriority = CONSTANTS.indexOf(rightType as any)
-        return (leftPriority >= rightPriority ? leftType : rightType) as Constants
+const inferFromCount = <T extends C>(count: number) => {
+        return COMPONENT_COUNT_TO_TYPE[count as keyof typeof COMPONENT_COUNT_TO_TYPE] as T
 }
 
-export const inferPrimitiveType = (x: any): Constants => {
-        if (is.bol(x)) return 'bool'
-        if (is.str(x)) return 'texture'
-        if (is.num(x)) return Number.isInteger(x) ? 'int' : 'float'
-        if (is.arr(x)) return COMPONENT_COUNT_TO_TYPE[x.length as keyof typeof COMPONENT_COUNT_TO_TYPE] || 'float'
-        return 'float'
-}
-
-const inferFromCount = (count: number): Constants => {
-        return COMPONENT_COUNT_TO_TYPE[count as keyof typeof COMPONENT_COUNT_TO_TYPE]!
-}
-
-const inferFromArray = (arr: X[], c: NodeContext): Constants => {
-        if (arr.length === 0) return 'void'
+const inferFromArray = <T extends C>(arr: X<T>[], c: NodeContext) => {
+        if (arr.length === 0) return 'void' as T
         const [x] = arr
-        if (is.str(x)) return x as Constants // for struct
+        if (is.str(x)) return x as T // for struct
         const ret = infer(x, c)
         for (const x of arr.slice(1))
                 if (ret !== infer(x, c)) throw new Error(`glre node system error: defined scope return mismatch`)
         return ret
 }
 
-export const inferImpl = (target: NodeProxy, c: NodeContext): Constants => {
+export const inferFunction = <T extends C>(x: X) => {
+        return FUNCTION_RETURN_TYPES[x as keyof typeof FUNCTION_RETURN_TYPES] as T
+}
+
+export const inferImpl = <T extends C>(target: NodeProxy<T>, c: NodeContext): T => {
         const { type, props } = target
-        const { id, children = [], layout, inferFrom } = props
+        const { id, children = [], inferFrom, layout } = props
         const [x, y, z] = children
-        if (type === 'conversion') return x as Constants
-        if (type === 'operator') return inferOperator(infer(y, c), infer(z, c), x as string)
-        if (type === 'function') return inferFunction(x as string, children.slice(1), c)
+        if (type === 'conversion') return x
+        if (type === 'operator') return inferOperator(infer(y, c), infer(z, c), x)
         if (type === 'ternary') return inferOperator(infer(y, c), infer(z, c), 'add')
         if (type === 'builtin') return inferBuiltin(id)
-        if (type === 'define' && isConstants(layout?.type)) return layout?.type
+        if (type === 'function') return inferFunction(x) || infer(y, c)
+        if (type === 'define' && isConstants(layout?.type)) return layout?.type as T
         if (type === 'attribute' && is.arr(x) && c.gl?.count) return inferFromCount(x.length / c.gl.count)
         if (type === 'member') {
                 if (isSwizzle(x)) return inferFromCount(x.length)
                 if (isNodeProxy(y) && is.str(x)) {
-                        const field = y.props.fields?.[x] // for variable node of struct member
+                        const field = (y as any).props.fields?.[x] // for variable node of struct member
                         if (field) return infer(field, c)
                 }
-                return 'float' // fallback @TODO FIX
+                return 'float' as T // fallback @TODO FIX
         }
         if (inferFrom) return inferFromArray(inferFrom, c)
-        return infer(x, c)
+        return infer(x, c) // for uniform
 }
 
-export const infer = (target: X, c?: NodeContext | null): Constants => {
+export const infer = <T extends C>(target: X<T>, c?: NodeContext | null): T => {
         if (!c) c = {}
         if (!isNodeProxy(target)) return inferPrimitiveType(target)
         if (is.arr(target)) return inferFromCount(target.length)
-        if (!c.infers) c.infers = new WeakMap<NodeProxy, Constants>()
-        if (c.infers.has(target)) return c.infers.get(target)!
+        if (!c.infers) c.infers = new WeakMap<NodeProxy<T>, C>()
+        if (c.infers.has(target)) return c.infers.get(target) as T
         const ret = inferImpl(target, c)
         c.infers.set(target, ret)
         return ret

package/src/node/node.ts

@@ -2,13 +2,13 @@ import { is } from '../utils/helpers'
 import { code } from './code'
 import { assign, toVar } from './scope'
 import { conversionToConstant, isConversion, isFunction, isOperator, getId } from './utils'
-import type { Functions, NodeProps, NodeProxy, NodeTypes, Operators, X } from './types'
+import type { Functions, NodeProps, NodeProxy, NodeTypes, Operators, X, Constants as C } from './types'
 
 const toPrimitive = (x: X, hint: string) => {
         if (hint === 'string') return code(x)
 }
 
-export const node = (type: NodeTypes, props?: NodeProps | null, ...args: X[]) => {
+export const node = <T extends C>(type: NodeTypes, props?: NodeProps | null, ...args: X[]) => {
         if (!props) props = {}
         if (args.length) props.children = args
         const listeners = new Set<(value: any) => void>()
@@ -24,28 +24,30 @@ export const node = (type: NodeTypes, props?: NodeProps | null, ...args: X[]) =>
                 if (isOperator(key)) return (...y: X[]) => operator(key, x, ...y)
                 if (isFunction(key)) return (...y: X[]) => function_(key, x, ...y)
                 if (isConversion(key)) return () => conversion(conversionToConstant(key), x)
-                if (is.str(key)) return member(key, x) // for struct
+                if (is.str(key)) return member(key, x) // for struct and swizzling
         }
         const set = (_: unknown, key: string, y: X) => {
                 if (key === 'value') listeners.forEach((fun) => fun(y))
                 if (is.str(key)) member(key, x).assign(y)
                 return true
         }
-        const x = new Proxy({}, { get, set }) as unknown as NodeProxy
+        const x = new Proxy({}, { get, set }) as unknown as NodeProxy<T>
         return x
 }
 
-// headers
-export const attribute = (x: X, id = getId()) => node('attribute', { id }, x)
-export const constant = (x: X, id = getId()) => node('constant', { id }, x)
-export const uniform = (x: X, id = getId()) => node('uniform', { id }, x)
-export const variable = (id = getId()) => node('variable', { id })
-export const builtin = (id = getId()) => node('builtin', { id })
-export const vertexStage = (x: X, id = getId()) => node('varying', { id, inferFrom: [x] }, x)
+// headers with proper type inference
+export const attribute = <T extends C>(x: X, id = getId()) => node<T>('attribute', { id }, x)
+export const constant = <T extends C>(x: X<T>, id = getId()) => node<T>('constant', { id }, x)
+export const uniform = <T extends C>(x: X<T>, id = getId()) => node<T>('uniform', { id }, x)
+export const variable = <T extends C>(id = getId()) => node<T>('variable', { id })
+export const builtin = <T extends C>(id = getId()) => node<T>('builtin', { id })
+export const vertexStage = <T extends C>(x: X<T>, id = getId()) => {
+        return node<T>('varying', { id, inferFrom: [x] }, x)
+}
 
-// Node shorthands
-export const operator = (key: Operators, ...x: X[]) => node('operator', null, key, ...x)
-export const function_ = (key: Functions, ...x: X[]) => node('function', null, key, ...x)
-export const conversion = (key: string, ...x: X[]) => node('conversion', null, key, ...x)
-export const member = (key: string, x: X) => node('member', null, key, x)
-export const select = (x: X, y: X, z: X) => node('ternary', null, x, y, z) // x ? y : z @TODO REMOVE
+// Node shorthands with proper typing
+export const member = <T extends C>(key: string, x: X) => node<T>('member', null, key, x)
+export const select = <T extends C>(x: X<T>, y: X<T>, z: X) => node<T>('ternary', null, x, y, z) // z ? x : y @TODO REMOVE
+export const operator = <T extends C>(key: Operators, ...x: X[]) => node<T>('operator', null, key, ...x)
+export const function_ = <T extends C>(key: Functions, ...x: X[]) => node<T>('function', null, key, ...x)
+export const conversion = <T extends C>(key: T, ...x: X[]) => node<T>('conversion', null, key, ...x)

package/src/node/parse.ts

@@ -1,7 +1,7 @@
 import { is } from '../utils/helpers'
 import { code } from './code'
 import { infer } from './infer'
-import { formatConversions, isConstants, addDependency } from './utils'
+import { formatConversions, addDependency } from './utils'
 import type { Constants, NodeContext, NodeProps, NodeProxy, X } from './types'
 
 export const parseArray = (children: X[], c: NodeContext) => {
@@ -58,37 +58,6 @@ export const parseDeclare = (c: NodeContext, x: X, y: X) => {
         return `var ${varName}: ${wgslType} = ${code(x, c)};`
 }
 
-export const parseDefine = (c: NodeContext, props: NodeProps, returnType: Constants | string) => {
-        const { id, children = [], layout } = props
-        const [x, ...args] = children
-        const argParams: [name: string, type: string][] = []
-        const params: string[] = []
-        if (layout?.inputs)
-                for (const input of layout.inputs) {
-                        argParams.push([input.name, input.type])
-                }
-        else
-                for (let i = 0; i < args.length; i++) {
-                        argParams.push([`p${i}`, infer(args[i], c)])
-                }
-        const ret = []
-        if (c?.isWebGL) {
-                for (const [paramId, type] of argParams) {
-                        addDependency(c, id!, type)
-                        params.push(`${type} ${paramId}`)
-                }
-                addDependency(c, id!, returnType)
-                ret.push(`${returnType} ${id}(${params}) {`)
-        } else {
-                for (const [paramId, type] of argParams) params.push(`${paramId}: ${formatConversions(type, c)}`)
-                ret.push(`fn ${id}(${params}) -> ${formatConversions(returnType, c)} {`)
-        }
-        const scopeCode = code(x, c)
-        if (scopeCode) ret.push(scopeCode)
-        ret.push('}')
-        return ret.join('\n')
-}
-
 export const parseStructHead = (c: NodeContext, id: string, fields: Record<string, NodeProxy> = {}) => {
         const lines: string[] = []
         for (const key in fields) {
@@ -123,11 +92,47 @@ export const parseStruct = (
         }
 }
 
+/**
+ * define
+ */
+export const parseDefine = (c: NodeContext, props: NodeProps, returnType: Constants) => {
+        const { id, children = [], layout } = props
+        const [x, ...args] = children
+        const argParams: [name: string, type: string][] = []
+        const params: string[] = []
+        if (layout?.inputs)
+                for (const input of layout.inputs) {
+                        argParams.push([input.name, input.type])
+                }
+        else
+                for (let i = 0; i < args.length; i++) {
+                        argParams.push([`p${i}`, infer(args[i], c)])
+                }
+        const ret = []
+        if (c?.isWebGL) {
+                for (const [paramId, type] of argParams) {
+                        addDependency(c, id!, type)
+                        params.push(`${type} ${paramId}`)
+                }
+                addDependency(c, id!, returnType)
+                ret.push(`${returnType} ${id}(${params}) {`)
+        } else {
+                for (const [paramId, type] of argParams) params.push(`${paramId}: ${formatConversions(type, c)}`)
+                ret.push(`fn ${id}(${params}) -> ${formatConversions(returnType, c)} {`)
+        }
+        const scopeCode = code(x, c)
+        if (scopeCode) ret.push(scopeCode)
+        ret.push('}')
+        return ret.join('\n')
+}
+
 /**
  * headers
  */
 export const parseVaryingHead = (c: NodeContext, id: string, type: string) => {
-        return c.isWebGL ? `${type} ${id};` : `@location(${c.code?.vertVaryings?.size || 0}) ${id}: ${formatConversions(type, c)}`
+        return c.isWebGL
+                ? `${type} ${id};`
+                : `@location(${c.code?.vertVaryings?.size || 0}) ${id}: ${formatConversions(type, c)}`
 }
 
 export const parseUniformHead = (c: NodeContext, id: string, type: Constants) => {

package/src/node/scope.ts

@@ -1,7 +1,6 @@
-import { int } from '.'
 import { conversion, node } from './node'
 import { getId } from './utils'
-import type { FnLayout, NodeProps, NodeProxy, X } from './types'
+import type { FnLayout, NodeProps, NodeProxy, X, Constants, Int } from './types'
 
 let scope: NodeProxy | null = null
 let define: NodeProxy | null = null
@@ -16,29 +15,28 @@ const addToScope = (x: NodeProxy) => {
         props.inferFrom.push(x)
 }
 
-export const toVar = (x: X, id?: string) => {
+export const toVar = <T extends Constants>(x: X<T>, id?: string): NodeProxy<T> => {
         if (!id) id = getId()
-        const y = node('variable', { id, inferFrom: [x] })
+        const y = node<T>('variable', { id, inferFrom: [x] })
         const z = node('declare', null, x, y)
         addToScope(z)
         return y
 }
 
-export const assign = (x: X, y: X) => {
+export const assign = <T extends Constants>(x: X<T>, y: X<T>): X<T> => {
         const z = node('assign', null, x, y)
         addToScope(z)
         return x
 }
 
-export const Return = (x: X) => {
-        const y = node('return', { inferFrom: [x] }, x)
+export const Return = <T extends Constants>(x: X<T>): NodeProxy<T> => {
+        const y = node<T>('return', { inferFrom: [x] }, x)
         addToScope(y)
         return y
 }
 
-// Struct functions
-export const struct = (fields: Record<string, NodeProxy>, id = getId()) => {
-        return (initialValues: Record<string, NodeProxy> = {}, instanceId = getId()) => {
+export const struct = <T extends Record<string, NodeProxy>>(fields: T, id = getId()) => {
+        return (initialValues: T = {} as T, instanceId = getId()) => {
                 const x = node('variable', { id: instanceId, inferFrom: [id] })
                 const y = node('struct', { id, fields, initialValues }, x)
                 addToScope(y)
@@ -61,7 +59,7 @@ const scoped = (x: NodeProxy, fun: () => NodeProxy | void, y = define) => {
         define = _define
 }
 
-export const If = (x: X, fun: () => void) => {
+export const If = (x: NodeProxy, fun: () => void) => {
         const y = node('scope')
         scoped(y, fun)
         const ifNode = node('if', null, x, y)
@@ -82,15 +80,16 @@ export const If = (x: X, fun: () => void) => {
         return ret()
 }
 
-export const Loop = (x: X, fun: (params: { i: NodeProxy }) => void) => {
+export const Loop = (x: NodeProxy, fun: (params: { i: Int }) => void) => {
         const y = node('scope')
-        scoped(y, () => fun({ i: node('variable', { id: 'i', inferFrom: [int(0)] }) }))
-        const ret = node('loop', null, x, y)
+        const id = getId()
+        scoped(y, () => fun({ i: node<'int'>('variable', { id, inferFrom: [conversion('int', 0)] }) }))
+        const ret = node('loop', { id }, x, y)
         addToScope(ret)
         return ret
 }
 
-export const Switch = (x: X) => {
+export const Switch = (x: NodeProxy) => {
         const switchNode = node('switch', null, x)
         addToScope(switchNode)
         const ret = () => ({
@@ -111,10 +110,13 @@ export const Switch = (x: X) => {
         return ret()
 }
 
-export const Fn = (fun: (paramVars: NodeProxy[]) => NodeProxy) => {
+export const Fn = <ReturnType extends Constants, Args extends Constants[]>(
+        fun: (paramVars: NodeProxy[]) => NodeProxy<ReturnType> | void,
+        defaultId = getId()
+) => {
         let layout: FnLayout
-        const ret = (...args: X[]) => {
-                const id = layout?.name || getId()
+        const ret = (...args: X<Args[number]>[]): NodeProxy<ReturnType> => {
+                const id = layout?.name || defaultId
                 const x = node('scope')
                 const paramVars: NodeProxy[] = []
                 const paramDefs: NodeProps[] = []
@@ -127,10 +129,13 @@ export const Fn = (fun: (paramVars: NodeProxy[]) => NodeProxy) => {
                                 paramDefs.push({ id: `p${i}`, inferFrom: [args[i]] })
                         }
                 for (const props of paramDefs) paramVars.push(node('variable', props))
-                const y = node('define', { id, layout }, x, ...args)
+                const y = node<ReturnType>('define', { id, layout }, x, ...args)
                 scoped(x, () => fun(paramVars), y)
                 return y
         }
-        ret.setLayout = (_layout: FnLayout) => void (layout = _layout)
+        ret.setLayout = (_layout: FnLayout) => {
+                layout = _layout
+                return ret
+        }
         return ret
 }