dazscript-framework 1.0.33 → 1.0.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dazscript-framework",
-  "version": "1.0.33",
+  "version": "1.0.34",
   "author": "Freddy Diaz",
   "license": "MPL-2.0",
   "description": "",

package/src/helpers/skeleton-helper.test.ts

@@ -0,0 +1,81 @@
+import { describe, expect, it } from 'vitest'
+import { getMirrorNameCandidate, getMirrorNodeMatch, getMirrorNodes } from './skeleton-helper'
+
+type TestNode = {
+    name: string
+    getName: () => string
+}
+
+const node = (name: string): TestNode => ({
+    name,
+    getName: () => name
+})
+
+const figure = (names: string[]) => ({
+    findNodeChild: (name: string) => names.indexOf(name) >= 0 ? node(name) : null
+})
+
+describe('skeleton mirror helper', () => {
+    it('resolves Genesis-style compact prefixes', () => {
+        expect(getMirrorNameCandidate('rThighBend')).toMatchObject({
+            side: 'right',
+            convention: 'compact-prefix',
+            sourceToken: 'r',
+            mirrorToken: 'l',
+            mirrorName: 'lThighBend'
+        })
+
+        expect(getMirrorNameCandidate('lHand')).toMatchObject({
+            side: 'left',
+            mirrorName: 'rHand'
+        })
+    })
+
+    it('resolves underscore prefix and suffix names', () => {
+        expect(getMirrorNameCandidate('right_hand')).toMatchObject({
+            side: 'right',
+            convention: 'underscore-prefix',
+            mirrorName: 'left_hand'
+        })
+
+        expect(getMirrorNameCandidate('hand_R')).toMatchObject({
+            side: 'right',
+            convention: 'underscore-suffix',
+            mirrorName: 'hand_L'
+        })
+    })
+
+    it('resolves word prefix and suffix names', () => {
+        expect(getMirrorNameCandidate('RightHand')).toMatchObject({
+            side: 'right',
+            convention: 'word-prefix',
+            mirrorName: 'LeftHand'
+        })
+
+        expect(getMirrorNameCandidate('HandLeft')).toMatchObject({
+            side: 'left',
+            convention: 'word-suffix',
+            mirrorName: 'HandRight'
+        })
+    })
+
+    it('does not classify center bones as mirrored', () => {
+        expect(getMirrorNameCandidate('hip')).toBeNull()
+        expect(getMirrorNameCandidate('abdomenLower')).toBeNull()
+    })
+
+    it('returns rich match metadata while keeping getMirrorNodes compatible', () => {
+        const testFigure = figure(['lThighBend', 'hip'])
+        const source = node('rThighBend')
+        const center = node('hip')
+
+        const match = getMirrorNodeMatch(testFigure as unknown as DzSkeleton, source as unknown as DzNode)
+
+        expect(match.side).toBe('right')
+        expect(match.mirror?.getName()).toBe('lThighBend')
+        expect(getMirrorNodes(testFigure as unknown as DzSkeleton, [
+            source as unknown as DzNode,
+            center as unknown as DzNode
+        ]).map(item => item.getName())).toEqual(['lThighBend'])
+    })
+})

package/src/helpers/skeleton-helper.ts

@@ -10,18 +10,143 @@ export const getModifiers = (figure: DzSkeleton): DzModifier[] => {
     return modifiers
 }
 
+export type MirrorSide = 'left' | 'right'
+
+export type MirrorNameConvention =
+    | 'compact-prefix'
+    | 'underscore-prefix'
+    | 'underscore-suffix'
+    | 'word-prefix'
+    | 'word-suffix'
+
+export type MirrorNodeMatch = {
+    source: DzNode
+    mirror: DzNode | null
+    side: MirrorSide | null
+    convention: MirrorNameConvention | null
+    sourceToken: string | null
+    mirrorToken: string | null
+    mirrorName: string | null
+}
+
+type MirrorNameCandidate = Omit<MirrorNodeMatch, 'source' | 'mirror'>
+
+const preserveCase = (source: string, replacement: string): string => {
+    if (source.toUpperCase() === source) return replacement.toUpperCase()
+    if (source.toLowerCase() === source) return replacement.toLowerCase()
+    if (source.length > 0 && source[0].toUpperCase() === source[0]) {
+        return replacement[0].toUpperCase() + replacement.substring(1).toLowerCase()
+    }
+
+    return replacement
+}
+
+export const getMirrorNameCandidate = (name: string): MirrorNameCandidate | null => {
+    const compactPrefix = /^([lr])([A-Z].*)$/.exec(name)
+    if (compactPrefix) {
+        const sourceToken = compactPrefix[1]
+        const mirrorToken = sourceToken === 'r' ? 'l' : 'r'
+        return {
+            side: sourceToken === 'r' ? 'right' : 'left',
+            convention: 'compact-prefix',
+            sourceToken,
+            mirrorToken,
+            mirrorName: `${mirrorToken}${compactPrefix[2]}`
+        }
+    }
+
+    const underscorePrefix = /^(r|l|right|left)([_-].+)$/i.exec(name)
+    if (underscorePrefix) {
+        const sourceToken = underscorePrefix[1]
+        const side = sourceToken.toLowerCase()[0] === 'r' ? 'right' : 'left'
+        const mirrorToken = preserveCase(sourceToken, sourceToken.length === 1
+            ? (side === 'right' ? 'l' : 'r')
+            : (side === 'right' ? 'left' : 'right'))
+        return {
+            side,
+            convention: 'underscore-prefix',
+            sourceToken,
+            mirrorToken,
+            mirrorName: `${mirrorToken}${underscorePrefix[2]}`
+        }
+    }
+
+    const underscoreSuffix = /^(.+[_-])(r|l|right|left)$/i.exec(name)
+    if (underscoreSuffix) {
+        const sourceToken = underscoreSuffix[2]
+        const side = sourceToken.toLowerCase()[0] === 'r' ? 'right' : 'left'
+        const mirrorToken = preserveCase(sourceToken, sourceToken.length === 1
+            ? (side === 'right' ? 'l' : 'r')
+            : (side === 'right' ? 'left' : 'right'))
+        return {
+            side,
+            convention: 'underscore-suffix',
+            sourceToken,
+            mirrorToken,
+            mirrorName: `${underscoreSuffix[1]}${mirrorToken}`
+        }
+    }
+
+    const wordPrefix = /^(right|left)([A-Z].*)$/i.exec(name)
+    if (wordPrefix) {
+        const sourceToken = wordPrefix[1]
+        const side = sourceToken.toLowerCase() === 'right' ? 'right' : 'left'
+        const mirrorToken = preserveCase(sourceToken, side === 'right' ? 'left' : 'right')
+        return {
+            side,
+            convention: 'word-prefix',
+            sourceToken,
+            mirrorToken,
+            mirrorName: `${mirrorToken}${wordPrefix[2]}`
+        }
+    }
+
+    const wordSuffix = /^(.+[a-z])(Right|Left)$/i.exec(name)
+    if (wordSuffix) {
+        const sourceToken = wordSuffix[2]
+        const side = sourceToken.toLowerCase() === 'right' ? 'right' : 'left'
+        const mirrorToken = preserveCase(sourceToken, side === 'right' ? 'left' : 'right')
+        return {
+            side,
+            convention: 'word-suffix',
+            sourceToken,
+            mirrorToken,
+            mirrorName: `${wordSuffix[1]}${mirrorToken}`
+        }
+    }
+
+    return null
+}
+
+export const getMirrorNodeMatch = (figure: DzSkeleton, node: DzNode): MirrorNodeMatch => {
+    const name = node.getName().valueOf()
+    const candidate = getMirrorNameCandidate(name)
+
+    if (!candidate) {
+        return {
+            source: node,
+            mirror: null,
+            side: null,
+            convention: null,
+            sourceToken: null,
+            mirrorToken: null,
+            mirrorName: null
+        }
+    }
+
+    return {
+        source: node,
+        mirror: figure.findNodeChild(candidate.mirrorName, true),
+        ...candidate
+    }
+}
+
+export const getMirrorNodeMatches = (figure: DzSkeleton, nodes: DzNode[]): MirrorNodeMatch[] => {
+    return nodes.map(node => getMirrorNodeMatch(figure, node))
+}
+
 export const getMirrorNodes = (figure: DzSkeleton, nodes: DzNode[]): DzNode[] => {
-    let mirrorNodes: DzNode[] = []
-
-    nodes.forEach((node) => {
-        const name = node.getName().valueOf()
-        let prefix = name[0]
-        if (prefix !== 'r' && prefix !== 'l') return
-        prefix = prefix === 'r' ? 'l' : 'r'
-        const mirrorName = `${prefix}${name.substring(1)}`
-        const mirrorNode = figure.findNodeChild(mirrorName, true)
-        if (mirrorNode) mirrorNodes.push(mirrorNode)
-    })
-
-    return mirrorNodes
-}
+    return getMirrorNodeMatches(figure, nodes)
+        .map(match => match.mirror)
+        .filter(node => node !== null) as DzNode[]
+}