@teleporthq/teleport-uidl-resolver 0.43.44 → 0.43.47

package/__tests__/abilities/utils.ts

@@ -208,6 +208,114 @@ describe('insertLink', () => {
     })
   })
 
+  it('resolves a navlink whose route value carries a folder prefix', () => {
+    // A details page's route value is folder-qualified (`add-event/Add-Event`)
+    // while the navlink still names the page (`Add-Event`). Matching only on
+    // the whole value missed every one of them and silently fabricated
+    // `/add-event` — a path with no file behind it.
+    const node = elementNode('container')
+    const navlink = navlinkMockedDefinition()
+    navlink.content.routeName = { type: 'static', content: 'Guild-Details' }
+    node.content.abilities = { link: navlink }
+
+    const result = insertLinks(
+      node,
+      {
+        projectRouteDefinition: {
+          type: 'route',
+          defaultValue: 'home',
+          values: [{ value: 'guild-details/Guild-Details', pageOptions: { navLink: '/guilds' } }],
+        },
+      },
+      false
+    )
+
+    expect(result.content.attrs.transitionTo.content).toBe('/guilds')
+  })
+
+  it('does not guess when two folders hold a page of the same name', () => {
+    const node = elementNode('container')
+    const navlink = navlinkMockedDefinition()
+    navlink.content.routeName = { type: 'static', content: 'Details' }
+    node.content.abilities = { link: navlink }
+
+    const result = insertLinks(
+      node,
+      {
+        projectRouteDefinition: {
+          type: 'route',
+          defaultValue: 'home',
+          values: [
+            { value: 'events/Details', pageOptions: { navLink: '/events/detail' } },
+            { value: 'guilds/Details', pageOptions: { navLink: '/guilds/detail' } },
+          ],
+        },
+      },
+      false
+    )
+
+    // Ambiguous → the pre-existing fallback, not an arbitrary pick.
+    expect(result.content.attrs.transitionTo.content).toBe('/details')
+  })
+
+  it('refuses to link a dynamic route that has no record id to fill it', () => {
+    // `/rsvp-event/[id]` is a TEMPLATE. Without a differentiator there is no id
+    // to substitute, so neither the template (a literal `[id]` in the address
+    // bar) nor the bare prefix (`/rsvp-event`, which matches no file) is
+    // navigable. Run 798e2775 shipped the bare prefix in the global footer of
+    // all 17 pages.
+    const node = elementNode('container')
+    const navlink = navlinkMockedDefinition()
+    navlink.content.routeName = { type: 'static', content: 'Add-Event' }
+    node.content.abilities = { link: navlink }
+
+    const result = insertLinks(
+      node,
+      {
+        projectRouteDefinition: {
+          type: 'route',
+          defaultValue: 'home',
+          values: [{ value: 'add-event/Add-Event', pageOptions: { navLink: '/add-event/[id]' } }],
+        },
+      },
+      false
+    )
+
+    expect(result.content.attrs.transitionTo.content).toBe('#')
+  })
+
+  it('still builds the record URL for a dynamic route WITH a differentiator', () => {
+    // The row-scoped case must keep working — it is the reason dynamic routes
+    // exist, and it is what the guard above must not touch.
+    const node = elementNode('container')
+    const navlink = navlinkMockedDefinition()
+    navlink.content.routeName = { type: 'static', content: 'Event-Details' }
+    navlink.content.differentiatorValue = {
+      type: 'dynamic',
+      content: { referenceType: 'global', refPath: ['Current User', 'id'] },
+    } as never
+    node.content.abilities = { link: navlink }
+
+    const result = insertLinks(
+      node,
+      {
+        projectRouteDefinition: {
+          type: 'route',
+          defaultValue: 'home',
+          values: [
+            { value: 'event-details/Event-Details', pageOptions: { navLink: '/event-details' } },
+          ],
+        },
+      },
+      false
+    )
+
+    expect(result.content.attrs.transitionTo).toEqual({
+      type: 'expr',
+      content: '`/event-details/' + '$' + '{' + 'currentUser?.id}' + '`',
+    })
+  })
+
   it('marks the link wrapper display:contents when the flex parent uses a project-referenced style', () => {
     const child = elementNode('container')
     child.content.abilities = { link: navlinkMockedDefinition() }

package/__tests__/unbound-expressions/expression-fallback.ts

@@ -0,0 +1,64 @@
+import { extractFallbackLiteral } from '../../src/resolvers/unbound-expressions/expression-fallback'
+
+describe('extractFallbackLiteral', () => {
+  it('returns the string literal an expression falls back to', () => {
+    expect(extractFallbackLiteral('company?.name || "N/A"')).toBe('N/A')
+    expect(extractFallbackLiteral("deal?.stage || 'Unassigned'")).toBe('Unassigned')
+    expect(extractFallbackLiteral('company?.logo ?? "https://cdn/placeholder.png"')).toBe(
+      'https://cdn/placeholder.png'
+    )
+  })
+
+  it('returns the last fallback of a chain', () => {
+    expect(extractFallbackLiteral('a || b || "last"')).toBe('last')
+    expect(extractFallbackLiteral('a ?? b ?? "last"')).toBe('last')
+  })
+
+  it('returns numeric fallbacks verbatim', () => {
+    expect(extractFallbackLiteral('parseFloat(item.price) || 0')).toBe('0')
+    expect(extractFallbackLiteral('item.ratio || 1.5')).toBe('1.5')
+    expect(extractFallbackLiteral('item.delta || -1')).toBe('-1')
+    expect(extractFallbackLiteral('item.delta || +1')).toBe('1')
+  })
+
+  it('accepts a template literal with no interpolation', () => {
+    expect(extractFallbackLiteral('item.label || `Untitled`')).toBe('Untitled')
+  })
+
+  it('rejects a template literal that still reads scope', () => {
+    // tslint:disable-next-line no-invalid-template-strings
+    expect(extractFallbackLiteral('item.label || `${item.id}`')).toBeNull()
+  })
+
+  it('ignores operators that live inside literals', () => {
+    expect(extractFallbackLiteral(`company?.size || "size || '-'"`)).toBe(`size || '-'`)
+    expect(extractFallbackLiteral(`"a || b"`)).toBeNull()
+  })
+
+  it('ignores operators nested inside parentheses, brackets or braces', () => {
+    expect(extractFallbackLiteral('fn(a || "inner")')).toBeNull()
+    expect(extractFallbackLiteral('map[a || "inner"]')).toBeNull()
+    expect(extractFallbackLiteral('{ key: a || "inner" }')).toBeNull()
+  })
+
+  it('rejects a fallback that is not a standalone literal', () => {
+    expect(extractFallbackLiteral('company?.name || buildName(company)')).toBeNull()
+    expect(extractFallbackLiteral(`company?.name || (a ? 'x' : 'y')`)).toBeNull()
+    expect(extractFallbackLiteral('company?.flag || true')).toBeNull()
+  })
+
+  it('does not confuse optional chaining or a ternary with a nullish fallback', () => {
+    expect(extractFallbackLiteral(`company?.name`)).toBeNull()
+    expect(extractFallbackLiteral(`company ? 'yes' : 'no'`)).toBeNull()
+  })
+
+  it('decodes escape sequences in the literal', () => {
+    expect(extractFallbackLiteral(`a || 'It\\'s here'`)).toBe("It's here")
+    expect(extractFallbackLiteral('a || "line\\nbreak"')).toBe('line\nbreak')
+  })
+
+  it('returns null for empty or non-string input', () => {
+    expect(extractFallbackLiteral('')).toBeNull()
+    expect(extractFallbackLiteral(undefined as unknown as string)).toBeNull()
+  })
+})

package/__tests__/unbound-expressions/expression-identifiers.ts

@@ -1,9 +1,11 @@
-import { extractRootIdentifiers } from '../../src/resolvers/unbound-expressions/expression-identifiers'
+import { analyzeExpressionScope } from '../../src/resolvers/unbound-expressions/expression-identifiers'
 
 const roots = (expression: string): string[] =>
-  Array.from(extractRootIdentifiers(expression)).sort()
+  Array.from(analyzeExpressionScope(expression).freeIdentifiers).sort()
 
-describe('extractRootIdentifiers', () => {
+const isResolvable = (expression: string): boolean => analyzeExpressionScope(expression).resolvable
+
+describe('analyzeExpressionScope', () => {
   it('returns the leading identifier of a member expression', () => {
     expect(roots('cat.name')).toEqual(['cat'])
     expect(roots('loc.location_id')).toEqual(['loc'])
@@ -56,6 +58,47 @@ describe('extractRootIdentifiers', () => {
 
   it('returns an empty set for empty or non-string input', () => {
     expect(roots('')).toEqual([])
-    expect(Array.from(extractRootIdentifiers(undefined as unknown as string))).toEqual([])
+    expect(
+      Array.from(analyzeExpressionScope(undefined as unknown as string).freeIdentifiers)
+    ).toEqual([])
+  })
+
+  it('subtracts identifiers bound by an arrow function parameter list', () => {
+    expect(roots('(event) => event.target.value')).toEqual([])
+    expect(roots('item => item.id')).toEqual([])
+    expect(roots('rows.map((row, i) => row.name + i)').sort()).toEqual(['rows'])
+    expect(roots('(a, b) => a + b + outer').sort()).toEqual(['outer'])
+  })
+
+  it('subtracts identifiers bound by a function expression', () => {
+    expect(roots('(function (a) { return a })')).toEqual([])
+    expect(roots('(function total(a) { return total(a) })')).toEqual([])
+    expect(roots('(function (a) { return a + outer })')).toEqual(['outer'])
+  })
+
+  it('keeps nested arrow scopes independent of the outer expression', () => {
+    // tslint:disable-next-line no-invalid-template-strings
+    expect(roots('groups.map((group) => group.items.map((entry) => entry.id))')).toEqual(['groups'])
+  })
+
+  it('still sees references that only appear outside a callback', () => {
+    expect(roots('outer.list.filter((x) => x.ok)').sort()).toEqual(['outer'])
+  })
+
+  it('reports block-scoped declarations as unresolvable rather than guessing', () => {
+    expect(isResolvable('(() => { const total = 1; return total })()')).toBe(false)
+    expect(isResolvable('(() => { let total = 1; return total })()')).toBe(false)
+    expect(isResolvable('(() => { var total = 1; return total })()')).toBe(false)
+    expect(isResolvable('props.value')).toBe(true)
+    expect(isResolvable('(event) => event.target.value')).toBe(true)
+  })
+
+  it('does not mistake a property named like a keyword for a declaration', () => {
+    expect(isResolvable('props.constant')).toBe(true)
+    expect(roots('props.constant')).toEqual(['props'])
+    // Reserved words are legal property names.
+    expect(isResolvable('props.const')).toBe(true)
+    expect(roots('props.const')).toEqual(['props'])
+    expect(roots('props.function + Math.max(a, b)').sort()).toEqual(['Math', 'a', 'b', 'props'])
   })
 })

package/__tests__/unbound-expressions/index.ts

@@ -24,6 +24,23 @@ const buildComponent = (node: UIDLElementNode): ComponentUIDL =>
     },
   } as unknown as ComponentUIDL)
 
+const containerWith = (children: UIDLNode[]): UIDLElementNode => ({
+  type: 'element',
+  content: { elementType: 'container', children },
+})
+
+// `console.warn` is the resolver's diagnostic channel; silence it so the suite
+// output stays readable while still exercising the code path.
+let warnSpy: jest.SpyInstance
+
+beforeEach(() => {
+  warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => undefined)
+})
+
+afterEach(() => {
+  warnSpy.mockRestore()
+})
+
 describe('resolveUnboundExpressions', () => {
   it('neutralises an orphaned option expression that references an unbound iterator', () => {
     const option = optionWith(expr('cat.name'))
@@ -54,16 +71,65 @@ describe('resolveUnboundExpressions', () => {
         },
       },
     } as UIDLNode
-    const uidl = buildComponent({
-      type: 'element',
-      content: { elementType: 'container', children: [repeater] },
-    })
+    const uidl = buildComponent(containerWith([repeater]))
 
     resolveUnboundExpressions(uidl)
 
     expect(boundExpr).toEqual({ type: 'expr', content: 'item?.id' })
   })
 
+  it('keeps the `index` a list repeater binds alongside its render prop', () => {
+    const indexExpr = expr('index + 1')
+    const repeater: UIDLNode = {
+      type: 'cms-list-repeater',
+      content: {
+        elementType: 'fragment',
+        name: 'list',
+        key: 'list',
+        renderPropIdentifier: 'item',
+        nodes: {
+          list: {
+            type: 'element',
+            content: { elementType: 'div', children: [indexExpr] },
+          },
+        },
+      },
+    } as UIDLNode
+    const uidl = buildComponent(containerWith([repeater]))
+
+    resolveUnboundExpressions(uidl)
+
+    expect(indexExpr).toEqual({ type: 'expr', content: 'index + 1' })
+  })
+
+  it('keeps `index` inside a repeat that opts into it and drops it otherwise', () => {
+    const indexed: UIDLElementNode = {
+      type: 'element',
+      content: { elementType: 'div', children: [expr('index')] },
+    }
+    const notIndexed: UIDLElementNode = {
+      type: 'element',
+      content: { elementType: 'div', children: [expr('index')] },
+    }
+    const repeatNode = (child: UIDLElementNode, useIndex: boolean): UIDLNode =>
+      ({
+        type: 'repeat',
+        content: {
+          node: child,
+          dataSource: { type: 'dynamic', content: { referenceType: 'prop', id: 'inventoryItem' } },
+          meta: { iteratorName: 'row', useIndex },
+        },
+      } as UIDLNode)
+    const uidl = buildComponent(
+      containerWith([repeatNode(indexed, true), repeatNode(notIndexed, false)])
+    )
+
+    resolveUnboundExpressions(uidl)
+
+    expect(indexed.content.children[0]).toEqual({ type: 'expr', content: 'index' })
+    expect(notIndexed.content.children[0]).toEqual({ type: 'static', content: '' })
+  })
+
   it('flags a repeater iterator referenced outside of its subtree', () => {
     const escaped = optionWith(expr('item?.id'))
     const repeater: UIDLNode = {
@@ -78,35 +144,49 @@ describe('resolveUnboundExpressions', () => {
         },
       },
     } as UIDLNode
-    const uidl = buildComponent({
-      type: 'element',
-      content: { elementType: 'container', children: [repeater, escaped] },
-    })
+    const uidl = buildComponent(containerWith([repeater, escaped]))
 
     resolveUnboundExpressions(uidl)
 
     expect(escaped.content.children[0]).toEqual({ type: 'static', content: '' })
   })
 
-  it('keeps expressions that reference props, state, globals and event', () => {
+  it('keeps expressions that reference props, state and globals', () => {
     const propsExpr = expr('props.inventoryItem?.name')
     const stateExpr = expr('categoryOptions')
-    const globalExpr = expr('JSON.stringify(params)')
-    const eventExpr = expr('event.target.value')
-    const uidl = buildComponent({
-      type: 'element',
-      content: {
-        elementType: 'container',
-        children: [propsExpr, stateExpr, globalExpr, eventExpr],
-      },
-    })
+    const globalExpr = expr('JSON.stringify(props.inventoryItem)')
+    const uidl = buildComponent(containerWith([propsExpr, stateExpr, globalExpr]))
 
     resolveUnboundExpressions(uidl)
 
     expect(propsExpr).toEqual({ type: 'expr', content: 'props.inventoryItem?.name' })
     expect(stateExpr).toEqual({ type: 'expr', content: 'categoryOptions' })
-    expect(globalExpr).toEqual({ type: 'expr', content: 'JSON.stringify(params)' })
-    expect(eventExpr).toEqual({ type: 'expr', content: 'event.target.value' })
+    expect(globalExpr).toEqual({ type: 'expr', content: 'JSON.stringify(props.inventoryItem)' })
+  })
+
+  it('neutralises the renderer-only `state` object, which generated code never declares', () => {
+    // Regression: React state is destructured into bare variables, so a `state`
+    // reference that survived the editor export compiles to
+    // `ReferenceError: state is not defined` and fails `next build`.
+    const container = containerWith([expr('state'), expr('state.addressLine')])
+    const uidl = buildComponent(container)
+
+    resolveUnboundExpressions(uidl)
+
+    expect(container.content.children).toEqual([
+      { type: 'static', content: '' },
+      { type: 'static', content: '' },
+    ])
+  })
+
+  it('keeps a state named `state` when the component actually declares it', () => {
+    const container = containerWith([expr('state')])
+    const uidl = buildComponent(container)
+    uidl.stateDefinitions.state = { type: 'string', defaultValue: '' }
+
+    resolveUnboundExpressions(uidl)
+
+    expect(container.content.children).toEqual([{ type: 'expr', content: 'state' }])
   })
 
   it('neutralises an unbound expression used as an attribute value', () => {
@@ -147,6 +227,79 @@ describe('resolveUnboundExpressions', () => {
     ])
   })
 
+  it('keeps the literal fallback an unbound expression was authored with', () => {
+    const srcAttr: UIDLElementNode = {
+      type: 'element',
+      content: {
+        elementType: 'image',
+        attrs: { src: { type: 'expr', content: `company?.logo ?? 'https://cdn/placeholder.png'` } },
+        children: [],
+      },
+    }
+    const container = containerWith([expr(`company?.name || "N/A"`), srcAttr])
+    const uidl = buildComponent(container)
+
+    resolveUnboundExpressions(uidl)
+
+    expect(container.content.children[0]).toEqual({ type: 'static', content: 'N/A' })
+    expect(srcAttr.content.attrs!.src).toEqual({
+      type: 'static',
+      content: 'https://cdn/placeholder.png',
+    })
+  })
+
+  it('does not mistake a fallback-looking literal inside a string for a real fallback', () => {
+    const container = containerWith([expr(`company?.size || "size || '-'"`)])
+    const uidl = buildComponent(container)
+
+    resolveUnboundExpressions(uidl)
+
+    expect(container.content.children[0]).toEqual({ type: 'static', content: `size || '-'` })
+  })
+
+  it('blanks rather than guesses when the fallback is not a plain literal', () => {
+    const container = containerWith([expr('company?.name || buildName(company)')])
+    const uidl = buildComponent(container)
+
+    resolveUnboundExpressions(uidl)
+
+    expect(container.content.children[0]).toEqual({ type: 'static', content: '' })
+  })
+
+  it('keeps an inline callback whose parameter is declared by the expression itself', () => {
+    const callbackExpr = expr('(event) => event.target.value')
+    // tslint:disable-next-line no-invalid-template-strings
+    const arrowExpr = expr('props.inventoryItem.tags.map((tag, i) => `${i}:${tag}`).join()')
+    const container = containerWith([callbackExpr, arrowExpr])
+    const uidl = buildComponent(container)
+
+    resolveUnboundExpressions(uidl)
+
+    expect(container.content.children).toEqual([callbackExpr, arrowExpr])
+  })
+
+  it('leaves an expression alone when it declares bindings the analyser cannot resolve', () => {
+    const iife = expr('(() => { const total = 2; return total })()')
+    const container = containerWith([iife])
+    const uidl = buildComponent(container)
+
+    resolveUnboundExpressions(uidl)
+
+    expect(container.content.children).toEqual([iife])
+  })
+
+  it('does not treat quoted JSON payloads as references', () => {
+    const filterExpr = expr(
+      `JSON.stringify([{ "type": "condition", "source": "id", "operand": "=" }])`
+    )
+    const container = containerWith([filterExpr])
+    const uidl = buildComponent(container)
+
+    resolveUnboundExpressions(uidl)
+
+    expect(container.content.children).toEqual([filterExpr])
+  })
+
   it('keeps a navlink transitionTo that references a global-context identifier', () => {
     // Regression: the abilities resolver emits transitionTo exprs like
     // `/profile/${currentUser?.id}` for details navlinks bound to
@@ -163,10 +316,7 @@ describe('resolveUnboundExpressions', () => {
         children: [],
       },
     }
-    const uidl = buildComponent({
-      type: 'element',
-      content: { elementType: 'container', children: [link] },
-    })
+    const uidl = buildComponent(containerWith([link]))
 
     resolveUnboundExpressions(uidl)
 
@@ -176,4 +326,46 @@ describe('resolveUnboundExpressions', () => {
       content: '`/profile/${currentUser?.id}`',
     })
   })
+
+  it('neutralises an unbound reference inside a template literal', () => {
+    const link: UIDLElementNode = {
+      type: 'element',
+      content: {
+        elementType: 'navlink',
+        attrs: {
+          // tslint:disable-next-line no-invalid-template-strings
+          transitionTo: { type: 'expr', content: '`/deal-details/${deal?.id}`' },
+        },
+        children: [],
+      },
+    }
+    const uidl = buildComponent(containerWith([link]))
+
+    resolveUnboundExpressions(uidl)
+
+    expect(link.content.attrs.transitionTo).toEqual({ type: 'static', content: '' })
+  })
+
+  it('keeps the render prop a data-source node introduces for its children', () => {
+    const boundExpr = expr('dataSourceData?.title')
+    const dataSource: UIDLNode = {
+      type: 'data-source-item',
+      content: {
+        elementType: 'DataProvider',
+        renderPropIdentifier: 'dataSourceData',
+        resourceDefinition: {
+          type: 'external-data-source',
+          dataSourceId: 'ds-1',
+          tableName: 'items',
+          dataSourceType: 'postgresql',
+        },
+        children: [{ type: 'element', content: { elementType: 'div', children: [boundExpr] } }],
+      },
+    } as UIDLNode
+    const uidl = buildComponent(containerWith([dataSource]))
+
+    resolveUnboundExpressions(uidl)
+
+    expect(boundExpr).toEqual({ type: 'expr', content: 'dataSourceData?.title' })
+  })
 })

package/dist/cjs/resolvers/abilities/utils.js

@@ -360,6 +360,16 @@ var createLinkAttributes = function (link, options) {
                     transitionTo: buildDifferentiatorTransitionTo(baseRoute, differentiatorValue),
                 };
             }
+            // No differentiator + a dynamic destination = nothing navigable. See
+            // UNRESOLVABLE_NAVLINK_HREF. Checked HERE rather than inside
+            // `resolveNavlink` so the differentiator branch above still receives the
+            // real `/prefix/[id]` template it needs to substitute the row id into.
+            if (baseRoute.type === 'static' &&
+                teleport_shared_1.RoutePaths.pathHasDynamicSegment(String(baseRoute.content))) {
+                return {
+                    transitionTo: { type: 'static', content: UNRESOLVABLE_NAVLINK_HREF },
+                };
+            }
             return {
                 transitionTo: baseRoute,
             };
@@ -382,6 +392,43 @@ var createLinkAttributes = function (link, options) {
             throw new Error("createLinkNode called with invalid link type '".concat(link.type, "'"));
     }
 };
+/**
+ * A route whose `value` is folder-qualified (`add-character/Add-Character`)
+ * still answers to its bare page name in a navlink's `routeName`
+ * (`Add-Character`) — the folder prefix is part of the ROUTE, not of the page's
+ * identity. Matching only on the whole value made every such lookup miss and
+ * fall through to the fabricated `/${friendlyURL}` below.
+ *
+ * Resolved only when the last segment identifies the route UNAMBIGUOUSLY; with
+ * two pages of the same name in different folders there is no way to tell which
+ * one was meant, so we keep the old miss rather than guess.
+ */
+var findRouteByName = function (values, routeName) {
+    var exact = values.find(function (routeItem) { return routeItem.value === routeName; });
+    if (exact) {
+        return exact;
+    }
+    // `value` is typed `string | number | boolean` — only a string route can carry
+    // a folder prefix, so anything else can never match by last segment.
+    var byLastSegment = values.filter(function (routeItem) {
+        return typeof routeItem.value === 'string' && routeItem.value.split('/').pop() === routeName;
+    });
+    return byLastSegment.length === 1 ? byLastSegment[0] : undefined;
+};
+/**
+ * A DYNAMIC route (`/rsvp-event/[id]`) is not a URL — it is a template that
+ * needs one record's id. A navlink with no `differentiatorValue` has no id to
+ * put there, so neither spelling is navigable: the template ships a literal
+ * `[id]` in the address bar, and the bare prefix (`/rsvp-event`) matches no file
+ * and 404s. `#` is the platform's existing representation for a link that
+ * cannot be resolved — the element still renders, it just does not navigate,
+ * which is strictly better than a link that provably fails.
+ *
+ * This is the last line of defence, not the fix: a nav or CTA link pointing at a
+ * single-record page is a planning defect, and the generator that produced the
+ * UIDL is where it should be prevented.
+ */
+var UNRESOLVABLE_NAVLINK_HREF = '#';
 var resolveNavlink = function (route, options) {
     var _a, _b;
     if (options.skipNavlinkResolver) {
@@ -397,7 +444,7 @@ var resolveNavlink = function (route, options) {
     }
     var friendlyURL = teleport_shared_1.StringUtils.camelCaseToDashCase(teleport_shared_1.StringUtils.removeIllegalCharacters(routeName.toString()));
     var transitionRoute = options.projectRouteDefinition
-        ? options.projectRouteDefinition.values.find(function (routeItem) { return routeItem.value === routeName; })
+        ? findRouteByName(options.projectRouteDefinition.values, routeName.toString())
         : null;
     if (!transitionRoute) {
         return {