glre 0.48.0 → 0.49.1

package/dist/react.d.ts

@@ -29,8 +29,54 @@ declare const TYPE_MAPPING: {
     readonly struct: "struct";
 };
 declare const CONSTANTS: (keyof typeof TYPE_MAPPING)[];
+declare const SWIZZLE_BASE_MAP: {
+    readonly float: "float";
+    readonly vec2: "float";
+    readonly vec3: "float";
+    readonly vec4: "float";
+    readonly int: "int";
+    readonly ivec2: "int";
+    readonly ivec3: "int";
+    readonly ivec4: "int";
+    readonly uint: "uint";
+    readonly uvec2: "uint";
+    readonly uvec3: "uint";
+    readonly uvec4: "uint";
+    readonly bool: "bool";
+    readonly bvec2: "bool";
+    readonly bvec3: "bool";
+    readonly bvec4: "bool";
+};
+declare const SWIZZLE_RESULT_MAP: {
+    float: {
+        readonly 1: "float";
+        readonly 2: "vec2";
+        readonly 3: "vec3";
+        readonly 4: "vec4";
+        readonly 9: "mat3";
+        readonly 16: "mat4";
+    };
+    int: {
+        readonly 1: "int";
+        readonly 2: "ivec2";
+        readonly 3: "ivec3";
+        readonly 4: "ivec4";
+    };
+    uint: {
+        readonly 1: "uint";
+        readonly 2: "uvec2";
+        readonly 3: "uvec3";
+        readonly 4: "uvec4";
+    };
+    bool: {
+        readonly 1: "bool";
+        readonly 2: "bvec2";
+        readonly 3: "bvec3";
+        readonly 4: "bvec4";
+    };
+};
 declare const OPERATORS: {
-    readonly not: "";
+    readonly not: "!";
     readonly add: "+";
     readonly sub: "-";
     readonly mul: "*";
@@ -78,7 +124,7 @@ type Operators = (typeof OPERATOR_KEYS)[number];
  */
 interface FnLayout {
     name: string;
-    type: C | 'auto';
+    type?: C | 'auto';
     inputs?: Array<{
         name: string;
         type: C | 'auto';
@@ -117,6 +163,15 @@ interface NodeContext {
         structStructFields: Map<string, StructFields>;
     };
 }
+/**
+ * swizzle
+ */
+type _SwizzleLength<A extends string> = A extends `${infer _}${infer A}` ? A extends '' ? 1 : A extends `${infer _}${infer B}` ? B extends '' ? 2 : B extends `${infer _}${infer C}` ? C extends '' ? 3 : 4 : never : never : never;
+type _SwizzleBaseMap = typeof SWIZZLE_BASE_MAP;
+type _SwizzleResultMap = typeof SWIZZLE_RESULT_MAP;
+type _SwizzleBase<T extends C> = T extends keyof _SwizzleBaseMap ? _SwizzleBaseMap[T] : never;
+type _SwizzleResult<T extends C, L extends 1 | 2 | 3 | 4> = _SwizzleResultMap[_SwizzleBase<T>][L];
+type InferSwizzleType<T extends C, S extends string> = _SwizzleLength<S> extends infer L extends 1 | 2 | 3 | 4 ? _SwizzleResult<_SwizzleBase<T>, L> : never;
 /**
  * infer
  */
@@ -127,57 +182,6 @@ type ExtractPairs<T> = T extends readonly [infer L, infer R, string] ? [L, R] |
 type OperatorTypeRules = ExtractPairs<_OperatorTypeRulesMap[number]>;
 type IsInRules<L extends C, R extends C> = [L, R] extends OperatorTypeRules ? 1 : 0;
 type ValidateOperator<L extends C, R extends C> = L extends R ? 1 : IsInRules<L, R>;
-/**
- * swizzle
- */
-type _SwizzleLength<A extends string> = A extends `${infer _}${infer A}` ? A extends '' ? 1 : A extends `${infer _}${infer B}` ? B extends '' ? 2 : B extends `${infer _}${infer C}` ? C extends '' ? 3 : 4 : never : never : never;
-type _SwizzleBaseMap = {
-    float: 'float';
-    vec2: 'float';
-    vec3: 'float';
-    vec4: 'float';
-    int: 'int';
-    ivec2: 'int';
-    ivec3: 'int';
-    ivec4: 'int';
-    uint: 'uint';
-    uvec2: 'uint';
-    uvec3: 'uint';
-    uvec4: 'uint';
-    bool: 'bool';
-    bvec2: 'bool';
-    bvec3: 'bool';
-    bvec4: 'bool';
-};
-type _SwizzleResultMap = {
-    float: {
-        1: 'float';
-        2: 'vec2';
-        3: 'vec3';
-        4: 'vec4';
-    };
-    int: {
-        1: 'int';
-        2: 'ivec2';
-        3: 'ivec3';
-        4: 'ivec4';
-    };
-    uint: {
-        1: 'uint';
-        2: 'uvec2';
-        3: 'uvec3';
-        4: 'uvec4';
-    };
-    bool: {
-        1: 'bool';
-        2: 'bvec2';
-        3: 'bvec3';
-        4: 'bvec4';
-    };
-};
-type _SwizzleBase<T extends C> = T extends keyof _SwizzleBaseMap ? _SwizzleBaseMap[T] : never;
-type _SwizzleResult<T extends C, L extends 1 | 2 | 3 | 4> = _SwizzleResultMap[_SwizzleBase<T>][L];
-type InferSwizzleType<T extends C, S extends string> = _SwizzleLength<S> extends infer L extends 1 | 2 | 3 | 4 ? _SwizzleResult<_SwizzleBase<T>, L> : never;
 /**
  * Swizzles
  */

package/dist/solid.d.ts

@@ -29,8 +29,54 @@ declare const TYPE_MAPPING: {
     readonly struct: "struct";
 };
 declare const CONSTANTS: (keyof typeof TYPE_MAPPING)[];
+declare const SWIZZLE_BASE_MAP: {
+    readonly float: "float";
+    readonly vec2: "float";
+    readonly vec3: "float";
+    readonly vec4: "float";
+    readonly int: "int";
+    readonly ivec2: "int";
+    readonly ivec3: "int";
+    readonly ivec4: "int";
+    readonly uint: "uint";
+    readonly uvec2: "uint";
+    readonly uvec3: "uint";
+    readonly uvec4: "uint";
+    readonly bool: "bool";
+    readonly bvec2: "bool";
+    readonly bvec3: "bool";
+    readonly bvec4: "bool";
+};
+declare const SWIZZLE_RESULT_MAP: {
+    float: {
+        readonly 1: "float";
+        readonly 2: "vec2";
+        readonly 3: "vec3";
+        readonly 4: "vec4";
+        readonly 9: "mat3";
+        readonly 16: "mat4";
+    };
+    int: {
+        readonly 1: "int";
+        readonly 2: "ivec2";
+        readonly 3: "ivec3";
+        readonly 4: "ivec4";
+    };
+    uint: {
+        readonly 1: "uint";
+        readonly 2: "uvec2";
+        readonly 3: "uvec3";
+        readonly 4: "uvec4";
+    };
+    bool: {
+        readonly 1: "bool";
+        readonly 2: "bvec2";
+        readonly 3: "bvec3";
+        readonly 4: "bvec4";
+    };
+};
 declare const OPERATORS: {
-    readonly not: "";
+    readonly not: "!";
     readonly add: "+";
     readonly sub: "-";
     readonly mul: "*";
@@ -78,7 +124,7 @@ type Operators = (typeof OPERATOR_KEYS)[number];
  */
 interface FnLayout {
     name: string;
-    type: C | 'auto';
+    type?: C | 'auto';
     inputs?: Array<{
         name: string;
         type: C | 'auto';
@@ -117,6 +163,15 @@ interface NodeContext {
         structStructFields: Map<string, StructFields>;
     };
 }
+/**
+ * swizzle
+ */
+type _SwizzleLength<A extends string> = A extends `${infer _}${infer A}` ? A extends '' ? 1 : A extends `${infer _}${infer B}` ? B extends '' ? 2 : B extends `${infer _}${infer C}` ? C extends '' ? 3 : 4 : never : never : never;
+type _SwizzleBaseMap = typeof SWIZZLE_BASE_MAP;
+type _SwizzleResultMap = typeof SWIZZLE_RESULT_MAP;
+type _SwizzleBase<T extends C> = T extends keyof _SwizzleBaseMap ? _SwizzleBaseMap[T] : never;
+type _SwizzleResult<T extends C, L extends 1 | 2 | 3 | 4> = _SwizzleResultMap[_SwizzleBase<T>][L];
+type InferSwizzleType<T extends C, S extends string> = _SwizzleLength<S> extends infer L extends 1 | 2 | 3 | 4 ? _SwizzleResult<_SwizzleBase<T>, L> : never;
 /**
  * infer
  */
@@ -127,57 +182,6 @@ type ExtractPairs<T> = T extends readonly [infer L, infer R, string] ? [L, R] |
 type OperatorTypeRules = ExtractPairs<_OperatorTypeRulesMap[number]>;
 type IsInRules<L extends C, R extends C> = [L, R] extends OperatorTypeRules ? 1 : 0;
 type ValidateOperator<L extends C, R extends C> = L extends R ? 1 : IsInRules<L, R>;
-/**
- * swizzle
- */
-type _SwizzleLength<A extends string> = A extends `${infer _}${infer A}` ? A extends '' ? 1 : A extends `${infer _}${infer B}` ? B extends '' ? 2 : B extends `${infer _}${infer C}` ? C extends '' ? 3 : 4 : never : never : never;
-type _SwizzleBaseMap = {
-    float: 'float';
-    vec2: 'float';
-    vec3: 'float';
-    vec4: 'float';
-    int: 'int';
-    ivec2: 'int';
-    ivec3: 'int';
-    ivec4: 'int';
-    uint: 'uint';
-    uvec2: 'uint';
-    uvec3: 'uint';
-    uvec4: 'uint';
-    bool: 'bool';
-    bvec2: 'bool';
-    bvec3: 'bool';
-    bvec4: 'bool';
-};
-type _SwizzleResultMap = {
-    float: {
-        1: 'float';
-        2: 'vec2';
-        3: 'vec3';
-        4: 'vec4';
-    };
-    int: {
-        1: 'int';
-        2: 'ivec2';
-        3: 'ivec3';
-        4: 'ivec4';
-    };
-    uint: {
-        1: 'uint';
-        2: 'uvec2';
-        3: 'uvec3';
-        4: 'uvec4';
-    };
-    bool: {
-        1: 'bool';
-        2: 'bvec2';
-        3: 'bvec3';
-        4: 'bvec4';
-    };
-};
-type _SwizzleBase<T extends C> = T extends keyof _SwizzleBaseMap ? _SwizzleBaseMap[T] : never;
-type _SwizzleResult<T extends C, L extends 1 | 2 | 3 | 4> = _SwizzleResultMap[_SwizzleBase<T>][L];
-type InferSwizzleType<T extends C, S extends string> = _SwizzleLength<S> extends infer L extends 1 | 2 | 3 | 4 ? _SwizzleResult<_SwizzleBase<T>, L> : never;
 /**
  * Swizzles
  */

package/package.json

@@ -1,6 +1,6 @@
 {
         "name": "glre",
-        "version": "0.48.0",
+        "version": "0.49.1",
         "author": "tseijp",
         "license": "MIT",
         "private": false,

package/src/index.ts

@@ -54,7 +54,10 @@ export const createGL = (...args: Partial<GL>[]) => {
         gl('mount', async (el: HTMLCanvasElement) => {
                 gl.el = findElement(gl) || el || args.map(findElement).find(Boolean)
                 const isAppend = !gl.el // Check first: canvas may unmount during WebGPU async processing
-                if (isAppend && !gl.isNative) gl.el = document.createElement('canvas')
+                if (isAppend && !gl.isNative) {
+                        gl.el = document.createElement('canvas')
+                        Object.assign(gl.el.style, { top: 0, left: 0, position: 'fixed' })
+                }
                 for (let i = 0; i < args.length; i++) {
                         const arg = args[i]
                         gl.fs = arg.fs || arg.frag || arg.fragment || undefined

package/src/node/create.ts

@@ -8,9 +8,9 @@ const toPrimitive = (x: Y, hint: string) => {
         if (hint === 'string') return code(x as any, null)
 }
 
-export const create = <T extends C>(type: NodeTypes, props?: NodeProps | null, ...args: Y[]) => {
+export const create = <T extends C>(type: NodeTypes, props?: NodeProps | null, ...children: Y[]) => {
         if (!props) props = {}
-        if (args.length) props.children = args
+        if (children.length) props.children = children
         const listeners = new Set<(value: any) => void>()
         const get = (_: unknown, key: string | Symbol) => {
                 if (key === 'type') return type
@@ -30,20 +30,21 @@ export const create = <T extends C>(type: NodeTypes, props?: NodeProps | null, .
                 if (key === 'variable') return (id = getId()) => variable(id)
                 if (key === 'builtin') return (id = getId()) => builtin(id)
                 if (key === 'vertexStage') return (id = getId()) => vertexStage(x, id)
-                if (key === 'element') return (arg: Y) => (type === 'storage' ? gather(x, arg) : element(x, arg))
-                if (key === 'member') return (arg: Y) => member(x, arg)
+                if (key === 'element') return (y: Y) => (type === 'storage' ? gather(x, y) : element(x, y))
+                if (key === 'member') return (y: Y) => member(x, y)
                 if (key === 'assign') return assign.bind(null, x, x.type === 'gather')
                 if (key === 'select') return select.bind(null, x)
                 if (isOperator(key)) {
-                        return key.endsWith('Assign') ? (...args: Y[]) => addToScope(operator(key, x, ...args)) : (...args: Y[]) => operator(key, x, ...args)
+                        if (key.endsWith('Assign')) return (...y: Y[]) => addToScope(operator(key, x, ...y))
+                        return (...y: Y[]) => operator(key, x, ...y)
                 }
-                if (isFunction(key)) return (...args: Y[]) => function_(key, x, ...args)
+                if (isFunction(key)) return (...y: Y[]) => function_(key, x, ...y)
                 if (isConversion(key)) return () => conversion(getConstant(key), x)
                 if (is.str(key)) return isArrayAccess(key) ? element(x, key) : member(x, key)
         }
-        const set = (_: unknown, key: string, arg: Y) => {
-                if (key === 'value') listeners.forEach((fun) => fun(arg))
-                if (is.str(key)) member(x, key).assign(arg)
+        const set = (_: unknown, key: string, y: Y) => {
+                if (key === 'value') listeners.forEach((fun) => fun(y))
+                if (is.str(key)) member(x, key).assign(y)
                 return true
         }
         const x = new Proxy({}, { get, set }) as unknown as X<T>

package/src/node/scope.ts

@@ -1,23 +1,12 @@
 import { conversion, create } from './create'
-import type {
-        FnLayout,
-        FnType,
-        Constants as C,
-        Int,
-        NodeProps,
-        Struct,
-        StructFactory,
-        StructFields,
-        X,
-        Y,
-} from './types'
 import { getId } from './utils'
+import type { FnLayout, FnType, Constants as C, Int, NodeProps, Struct, StructFactory, StructFields, X, Y } from './types'
 
 let scope: X | null = null
 let define: X | null = null
 
 export const addToScope = <T extends C>(x: X<T>) => {
-        if (!scope) return
+        if (!scope) return x
         if (!scope.props.children) scope.props.children = []
         scope.props.children.push(x)
         if (x.type !== 'return' || !define) return x
@@ -133,8 +122,7 @@ export function Fn<T extends X | Struct | void, Args extends any[]>(fun: (args:
                         else
                                 paramDefs.push({
                                         id: input.name,
-                                        inferFrom:
-                                                input.type === 'auto' ? [args[i]] : [conversion(input.type, args[i])],
+                                        inferFrom: input.type === 'auto' ? [args[i]] : [conversion(input.type, args[i])],
                                 })
                 }
                 for (const props of paramDefs) paramVars.push(create('variable', props))

package/src/node/types.ts

@@ -1,4 +1,4 @@
-import { CONSTANTS, CONVERSIONS, FUNCTIONS, OPERATOR_KEYS, OPERATOR_TYPE_RULES } from './utils/const'
+import { CONSTANTS, CONVERSIONS, FUNCTIONS, OPERATOR_KEYS, OPERATOR_TYPE_RULES, SWIZZLE_BASE_MAP, SWIZZLE_RESULT_MAP } from './utils/const'
 import type { GL } from '../types'
 
 export type Constants = (typeof CONSTANTS)[number] | 'void'
@@ -11,7 +11,7 @@ export type Operators = (typeof OPERATOR_KEYS)[number]
  */
 export interface FnLayout {
         name: string
-        type: C | 'auto'
+        type?: C | 'auto'
         inputs?: Array<{
                 name: string
                 type: C | 'auto'
@@ -97,6 +97,24 @@ export interface NodeContext {
         }
 }
 
+/**
+ * swizzle
+ */
+// Optimized string length using direct pattern matching
+// prettier-ignore
+type _SwizzleLength<A extends string> =
+        A extends `${infer _}${infer A}` ? A extends '' ? 1 :
+        A extends `${infer _}${infer B}` ? B extends '' ? 2 :
+        B extends `${infer _}${infer C}` ? C extends '' ? 3 :
+        4 : never : never : never
+
+// Unified logic with infer.ts inferSwizzleType
+type _SwizzleBaseMap = typeof SWIZZLE_BASE_MAP
+type _SwizzleResultMap = typeof SWIZZLE_RESULT_MAP
+type _SwizzleBase<T extends C> = T extends keyof _SwizzleBaseMap ? _SwizzleBaseMap[T] : never
+type _SwizzleResult<T extends C, L extends 1 | 2 | 3 | 4> = _SwizzleResultMap[_SwizzleBase<T>][L]
+type InferSwizzleType<T extends C, S extends string> = _SwizzleLength<S> extends infer L extends 1 | 2 | 3 | 4 ? _SwizzleResult<_SwizzleBase<T>, L> : never
+
 /**
  * infer
  */
@@ -130,47 +148,6 @@ type OperatorTypeRules = ExtractPairs<_OperatorTypeRulesMap[number]>
 type IsInRules<L extends C, R extends C> = [L, R] extends OperatorTypeRules ? 1 : 0
 type ValidateOperator<L extends C, R extends C> = L extends R ? 1 : IsInRules<L, R>
 
-/**
- * swizzle
- */
-// Optimized string length using direct pattern matching
-// prettier-ignore
-type _SwizzleLength<A extends string> =
-        A extends `${infer _}${infer A}` ? A extends '' ? 1 :
-        A extends `${infer _}${infer B}` ? B extends '' ? 2 :
-        B extends `${infer _}${infer C}` ? C extends '' ? 3 :
-        4 : never : never : never
-
-type _SwizzleBaseMap = {
-        float: 'float'
-        vec2: 'float'
-        vec3: 'float'
-        vec4: 'float'
-        int: 'int'
-        ivec2: 'int'
-        ivec3: 'int'
-        ivec4: 'int'
-        uint: 'uint'
-        uvec2: 'uint'
-        uvec3: 'uint'
-        uvec4: 'uint'
-        bool: 'bool'
-        bvec2: 'bool'
-        bvec3: 'bool'
-        bvec4: 'bool'
-}
-
-type _SwizzleResultMap = {
-        float: { 1: 'float'; 2: 'vec2'; 3: 'vec3'; 4: 'vec4' }
-        int: { 1: 'int'; 2: 'ivec2'; 3: 'ivec3'; 4: 'ivec4' }
-        uint: { 1: 'uint'; 2: 'uvec2'; 3: 'uvec3'; 4: 'uvec4' }
-        bool: { 1: 'bool'; 2: 'bvec2'; 3: 'bvec3'; 4: 'bvec4' }
-}
-
-type _SwizzleBase<T extends C> = T extends keyof _SwizzleBaseMap ? _SwizzleBaseMap[T] : never
-type _SwizzleResult<T extends C, L extends 1 | 2 | 3 | 4> = _SwizzleResultMap[_SwizzleBase<T>][L]
-type InferSwizzleType<T extends C, S extends string> = _SwizzleLength<S> extends infer L extends 1 | 2 | 3 | 4 ? _SwizzleResult<_SwizzleBase<T>, L> : never
-
 /**
  * Swizzles
  */

package/src/node/utils/const.ts

@@ -32,8 +32,34 @@ export const TYPE_MAPPING = {
 
 export const CONSTANTS = Object.keys(TYPE_MAPPING) as (keyof typeof TYPE_MAPPING)[]
 
+export const SWIZZLE_BASE_MAP = {
+        float: 'float',
+        vec2: 'float',
+        vec3: 'float',
+        vec4: 'float',
+        int: 'int',
+        ivec2: 'int',
+        ivec3: 'int',
+        ivec4: 'int',
+        uint: 'uint',
+        uvec2: 'uint',
+        uvec3: 'uint',
+        uvec4: 'uint',
+        bool: 'bool',
+        bvec2: 'bool',
+        bvec3: 'bool',
+        bvec4: 'bool',
+} as const
+
+export const SWIZZLE_RESULT_MAP = {
+        float: { 1: 'float', 2: 'vec2', 3: 'vec3', 4: 'vec4', 9: 'mat3', 16: 'mat4' } as const,
+        int: { 1: 'int', 2: 'ivec2', 3: 'ivec3', 4: 'ivec4' } as const,
+        uint: { 1: 'uint', 2: 'uvec2', 3: 'uvec3', 4: 'uvec4' } as const,
+        bool: { 1: 'bool', 2: 'bvec2', 3: 'bvec3', 4: 'bvec4' } as const,
+}
+
 export const OPERATORS = {
-        not: '', // IGNORED
+        not: '!',
         add: '+',
         sub: '-',
         mul: '*',
@@ -66,15 +92,6 @@ export const OPERATORS = {
 
 export const OPERATOR_KEYS = Object.keys(OPERATORS) as (keyof typeof OPERATORS)[]
 
-export const COMPONENT_COUNT_TO_TYPE = {
-        1: 'float',
-        2: 'vec2',
-        3: 'vec3',
-        4: 'vec4',
-        9: 'mat3',
-        16: 'mat4',
-} as const
-
 export const BUILTIN_TYPES = {
         // WGSL builtin variables
         position: 'vec4',

package/src/node/utils/index.ts

@@ -7,18 +7,20 @@ import type { Constants as C, NodeContext, Y } from '../types'
 
 export * from './utils'
 
+const parseNumber = (target = 0) => {
+        const ret = `${target}`
+        if (ret.includes('.')) return ret
+        // Check if this number should be an integer based on the inferred type
+        // For now, keep the original behavior to maintain compatibility
+        return ret + '.0'
+}
+
 export const code = <T extends C>(target: Y<T>, c?: NodeContext | null): string => {
         if (!c) c = {}
         initNodeContext(c)
         if (is.arr(target)) return parseArray(target, c)
         if (is.str(target)) return target
-        if (is.num(target)) {
-                const ret = `${target}`
-                if (ret.includes('.')) return ret
-                // Check if this number should be an integer based on the inferred type
-                // For now, keep the original behavior to maintain compatibility
-                return ret + '.0'
-        }
+        if (is.num(target)) return parseNumber(target)
         if (is.bol(target)) return target ? 'true' : 'false'
         if (!target) return ''
         if (!isX(target)) return ''
@@ -42,7 +44,12 @@ export const code = <T extends C>(target: Y<T>, c?: NodeContext | null): string
                         : `${code(storageNode, c)}[${code(indexNode, c)}] = ${code(y, c)};`
         }
         if (type === 'ternary') return c.isWebGL ? `(${code(z, c)} ? ${code(x, c)} : ${code(y, c)})` : `select(${code(x, c)}, ${code(y, c)}, ${code(z, c)})`
-        if (type === 'conversion') return `${getConversions(x, c)}(${parseArray(children.slice(1), c)})`
+        if (type === 'conversion') {
+                if (x === 'float') if (is.num(y)) return parseNumber(y) // no conversion needed, e.g., float(1.0) → 1.0
+                if (x === 'bool') if (is.bol(y)) return y ? 'true' : 'false'
+                if (x === 'int') if (is.num(y)) return `${y << 0}`
+                return `${getConversions(x, c)}(${parseArray(children.slice(1), c)})`
+        }
         if (type === 'operator') {
                 if (x === 'not' || x === 'bitNot') return `!${code(y, c)}`
                 if (x === 'mod') return code(mod(y, z), c)

package/src/node/utils/infer.ts

@@ -1,5 +1,5 @@
 import { isConstants, isElement, isX, isSwizzle } from './utils'
-import { BUILTIN_TYPES, COMPONENT_COUNT_TO_TYPE, FUNCTION_RETURN_TYPES, getOperatorResultType, validateOperatorTypes } from './const'
+import { BUILTIN_TYPES, FUNCTION_RETURN_TYPES, getOperatorResultType, SWIZZLE_BASE_MAP, SWIZZLE_RESULT_MAP, validateOperatorTypes } from './const'
 import { is, getStride, isFloat32 } from '../../helpers'
 import type { Constants as C, NodeContext, X, Y } from '../types'
 
@@ -7,7 +7,14 @@ const inferBuiltin = <T extends C>(id: string | undefined) => {
         return BUILTIN_TYPES[id as keyof typeof BUILTIN_TYPES] as T
 }
 
+// Unified logic with types.ts inferArrayElement type
+const inferSwizzleType = <T extends C>(L: T, len: 1 | 2 | 3 | 4): T => {
+        return SWIZZLE_RESULT_MAP[SWIZZLE_BASE_MAP[L as 'float']][len] as T
+}
+
+// Unified logic with types.ts InferOperator type
 const inferOperator = <T extends C>(L: T, R: T, op: string): T => {
+        if (op === 'not') return 'bool' as T // 'not' operator's right side is none, causing a warning in the next validator
         if (!validateOperatorTypes(L, R, op)) console.warn(`GLRE Type Warning: Invalid operator '${op}' between types '${L}' and '${R}'`)
         return getOperatorResultType(L, R, op) as T
 }
@@ -15,15 +22,15 @@ const inferOperator = <T extends C>(L: T, R: T, op: string): T => {
 export const inferPrimitiveType = <T extends C>(x: Y<T>) => {
         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) || isFloat32(x)) return COMPONENT_COUNT_TO_TYPE[x.length as keyof typeof COMPONENT_COUNT_TO_TYPE] as T
+        if (is.num(x)) return 'float' as T // @TODO FIX: Number.isInteger(x) ? 'int' : 'float'
+        if (is.arr(x) || isFloat32(x)) return SWIZZLE_RESULT_MAP.float[x.length as 1 | 2 | 3 | 4 | 9 | 16] as T
         if (isElement(x)) return 'texture' as T
         return 'void' as T
 }
 
 const inferFromCount = <T extends C>(count: number, error = console.warn, id = '') => {
-        const ret = COMPONENT_COUNT_TO_TYPE[count as keyof typeof COMPONENT_COUNT_TO_TYPE] as T
-        if (!ret) console.warn(`glre node system error: Cannot infer ${id ? `${id} ` : ''} type from array length ${count}. Check your data size. Supported: 1(float), 2(vec2), 3(vec3), 4(vec4), 9(mat3), 16(mat4)`)
+        const ret = SWIZZLE_RESULT_MAP.float[count as 1 | 2 | 3 | 4 | 9 | 16] as T
+        if (!ret) error(`glre node system error: Cannot infer ${id ? `${id} ` : ''} type from array length ${count}. Check your data size. Supported: 1(float), 2(vec2), 3(vec3), 4(vec4), 9(mat3), 16(mat4)`)
         return ret
 }
 
@@ -62,13 +69,13 @@ export const inferImpl = <T extends C>(target: X<T>, c: NodeContext): T => {
                 }
 
         if (type === 'member') {
-                if (isSwizzle(y)) return inferFromCount(y.length, c.gl?.error, id)
-                if (isX(x)) {
-                        const structType = infer(x, c)
-                        const fields = c.code?.structStructFields?.get(structType)
+                const constant = infer(x, c) // Check if struct first to avoid field/swizzle clash, e.g. Struct({ x: float(), y: float() })
+                if (!isConstants(constant)) {
+                        const fields = c.code?.structStructFields?.get(constant)
                         if (fields && fields[y]) return infer(fields[y], c) as T
                 }
-                return 'float' as T
+                if (isSwizzle(y)) return inferSwizzleType(constant, y.length as 1 | 2 | 3 | 4) as T
+                return 'float' as T // throw Error
         }
         if (inferFrom) return inferFromArray(inferFrom, c)
         return x ? infer(x, c) : ('void' as T) // for uniform and storage gather and scatter