@teleporthq/teleport-project-generator 0.44.0-alpha.0 → 0.44.0

package/__tests__/content-settings-propagation.ts

@@ -0,0 +1,53 @@
+import { ProjectUIDL } from '@teleporthq/teleport-types'
+import { createProjectGenerator } from '../src'
+import { createStrategyWithCommonGenerator } from './mocks'
+import projectUIDL from '../../../examples/test-samples/project-sample.json'
+
+/**
+ * Each content preset's settings reach the page generators on their own: a
+ * Help Center needs no Blog. Passed only inside the Blog's condition, a
+ * Help-Center-only project generated its help articles' transform with an
+ * EMPTY taxonomy — every article lost its categories' ids, and the article
+ * page's breadcrumbs showed "Help Center" and nothing after it.
+ */
+
+const helpCenterSettings = {
+  categories: [{ id: 'guides', name: 'Guides', slug: 'guides', children: [] }],
+}
+
+const generatedWith = async (uidl: ProjectUIDL) => {
+  const strategy = createStrategyWithCommonGenerator()
+  const generator = createProjectGenerator(strategy)
+  await generator.generateProject(uidl)
+  return (generator.pageGenerator.generateComponent as jest.Mock).mock.calls.map(
+    (call) => call[1] as Record<string, unknown>
+  )
+}
+
+describe('content preset settings handed to the page generators', () => {
+  it('include a Help Center’s on a project without a blog', async () => {
+    const uidl = JSON.parse(JSON.stringify(projectUIDL)) as ProjectUIDL
+    delete (uidl as { blogSettings?: unknown }).blogSettings
+    uidl.helpCenterSettings = helpCenterSettings as never
+
+    const pageOptions = await generatedWith(uidl)
+
+    expect(pageOptions.length).toBeGreaterThan(0)
+    for (const options of pageOptions) {
+      expect(options.helpCenterSettings).toEqual(helpCenterSettings)
+      expect(options).not.toHaveProperty('blogSettings')
+    }
+  })
+
+  it('include both presets’ when the project has both', async () => {
+    const uidl = JSON.parse(JSON.stringify(projectUIDL)) as ProjectUIDL
+    const blogSettings = { categories: [] }
+    uidl.blogSettings = blogSettings as never
+    uidl.helpCenterSettings = helpCenterSettings as never
+
+    const [options] = await generatedWith(uidl)
+
+    expect(options.blogSettings).toEqual(blogSettings)
+    expect(options.helpCenterSettings).toEqual(helpCenterSettings)
+  })
+})

package/__tests__/details-page-info-propagation.ts

@@ -0,0 +1,111 @@
+import { createPageUIDLs } from '../src/utils'
+import { createStrategyWithCommonGenerator } from './mocks'
+import {
+  conditionalNode,
+  dynamicNode,
+  elementNode,
+  staticNode,
+} from '@teleporthq/teleport-uidl-builders'
+import { ProjectUIDL } from '@teleporthq/teleport-types'
+
+// Regression guard: `detailsPageInfo` (the table-name metadata a page's
+// route-level `pageOptions` carries for entity-bound details pages) must
+// survive `createPageUIDL`'s output-options construction and land on the
+// final page UIDL's `outputOptions`. Without it, downstream plugins (e.g.
+// teleport-plugin-next-static-props' `pageHasSameTableMutationWorkflow`,
+// which decides getServerSideProps vs. getStaticProps+ISR) have no way to
+// correlate "the row this page reads" with "the table a same-page mutation
+// workflow writes to" — silently disabling that entire fix.
+describe('createPageUIDLs propagates detailsPageInfo to outputOptions', () => {
+  const buildProjectUIDL = (): ProjectUIDL => {
+    const routeRef = dynamicNode('state', 'route')
+
+    const homeNode = conditionalNode(
+      routeRef,
+      elementNode('container', {}, [staticNode('Home')]),
+      'home'
+    )
+    const detailsNode = conditionalNode(
+      routeRef,
+      elementNode('container', {}, [staticNode('Details')]),
+      'edit-press-item/[id]'
+    )
+
+    return {
+      name: 'testProject',
+      globals: {
+        settings: { language: 'en', title: 'Test Project' },
+        meta: [],
+        assets: [],
+      },
+      root: {
+        name: 'App',
+        stateDefinitions: {
+          route: {
+            type: 'string',
+            defaultValue: 'home',
+            values: [
+              {
+                value: 'home',
+                pageOptions: {
+                  navLink: '/',
+                  fileName: 'index',
+                  componentName: 'Home',
+                },
+              },
+              {
+                value: 'edit-press-item/[id]',
+                pageOptions: {
+                  navLink: '/edit-press-item/[id]',
+                  fileName: '[id]',
+                  componentName: 'EditPressItem',
+                  dynamicRouteAttribute: 'id',
+                  initialPropsData: {
+                    exposeAs: { name: 'pressItem', valuePath: [] },
+                    resource: { id: 'fetch-press-item', params: {} },
+                  },
+                  detailsPageInfo: {
+                    dataSourceId: 'ds-1',
+                    dataSourceName: 'TeleportHQ database',
+                    dataSourceType: 'teleport',
+                    tableName: 'press_items',
+                    differentiatorColumn: 'id',
+                    featureIdentifier: 'pressItem',
+                  },
+                },
+              },
+            ],
+          },
+        },
+        node: elementNode('Router', {}, [homeNode, detailsNode]),
+      },
+      components: {},
+    } as unknown as ProjectUIDL
+  }
+
+  it('carries detailsPageInfo through onto the details page outputOptions', () => {
+    const uidl = buildProjectUIDL()
+    const strategy = createStrategyWithCommonGenerator()
+
+    const pages = createPageUIDLs(uidl, strategy)
+    expect(pages).toHaveLength(2)
+
+    const detailsPage = pages.find((p) => p.name === 'EditPressItem')
+    expect(detailsPage).toBeDefined()
+    expect(detailsPage!.outputOptions?.dynamicRouteAttribute).toBe('id')
+    expect(detailsPage!.outputOptions?.detailsPageInfo?.tableName).toBe('press_items')
+    expect(detailsPage!.outputOptions?.detailsPageInfo?.differentiatorColumn).toBe('id')
+    expect(detailsPage!.outputOptions?.initialPropsData).toBeDefined()
+  })
+
+  it('leaves detailsPageInfo undefined for a regular page that is not a details page', () => {
+    const uidl = buildProjectUIDL()
+    const strategy = createStrategyWithCommonGenerator()
+
+    const pages = createPageUIDLs(uidl, strategy)
+    const homePage = pages.find((p) => p.name === 'Home')
+
+    expect(homePage).toBeDefined()
+    expect(homePage!.outputOptions?.detailsPageInfo).toBeUndefined()
+  })
+})

package/__tests__/file-handlers.ts

@@ -30,6 +30,40 @@ describe('createHtmlIndexFile', () => {
     expect(entryFile.content).toContain('<html')
     expect(entryFile.content).toContain('{{root-placeholder}}')
   })
+
+  it('puts the inline script error guard first in <head> when the project runs scripts of its own', async () => {
+    const uidl = {
+      ...uidlSample,
+      globals: {
+        ...uidlSample.globals,
+        assets: [],
+        customCode: { body: '<script>null.addEventListener("click", () => {})</script>' },
+      },
+    } as unknown as ProjectUIDL
+
+    const [entryFile] = await createEntryFile(uidl, createStrategyWithCommonGenerator(), {})
+    const { content } = entryFile
+    const firstScript = content.slice(content.indexOf('<script'))
+
+    expect(content.indexOf('<script')).toBeGreaterThan(content.indexOf('<head>'))
+    expect(firstScript.indexOf('stopImmediatePropagation')).toBeLessThan(
+      firstScript.indexOf('</script>')
+    )
+    expect(content.indexOf('stopImmediatePropagation')).toBeLessThan(
+      content.indexOf('null.addEventListener')
+    )
+  })
+
+  it('emits no guard for a project without scripts of its own', async () => {
+    const uidl = {
+      ...uidlSample,
+      globals: { ...uidlSample.globals, assets: [], customCode: { head: '<style></style>' } },
+    } as unknown as ProjectUIDL
+
+    const [entryFile] = await createEntryFile(uidl, createStrategyWithCommonGenerator(), {})
+
+    expect(entryFile.content).not.toContain('stopImmediatePropagation')
+  })
 })
 
 describe('createManifestJSONFile', () => {

package/__tests__/index.ts

@@ -56,7 +56,7 @@ describe('Generic Project Generator', () => {
           },
           designLanguage: undefined,
           mapping: {},
-          projectResources: {},
+          extractedResources: {},
           skipValidation: true,
         })
       )
@@ -64,6 +64,8 @@ describe('Generic Project Generator', () => {
 
       const routerUIDL = {
         ...uidl.root,
+        styleSetDefinitions: {},
+        propDefinitions: {},
         outputOptions: {
           fileName: 'index',
         },
@@ -112,7 +114,7 @@ describe('Generic Project Generator', () => {
       expect(generator.componentGenerator.generateComponent).toBeCalledTimes(4)
       expect(generator.componentGenerator.generateComponent).toBeCalledWith(
         expect.objectContaining({ name: 'ExpandableArea' }),
-        {
+        expect.objectContaining({
           assets: {
             identifier: null,
             mappings: {},
@@ -122,17 +124,24 @@ describe('Generic Project Generator', () => {
           },
           designLanguage: undefined,
           projectRouteDefinition: uidl.root.stateDefinitions.route,
-          projectResources: {},
+          extractedResources: {},
           mapping: {},
           skipValidation: true,
-        }
+          skipI18n: true,
+          projectComponents: expect.objectContaining({
+            ExpandableArea: expect.objectContaining({ name: 'ExpandableArea' }),
+            Modal: expect.objectContaining({ name: 'Modal' }),
+            ModalWindow: expect.objectContaining({ name: 'ModalWindow' }),
+            OneComponent: expect.objectContaining({ name: 'OneComponent' }),
+          }),
+        })
       )
       expect(generator.pageGenerator.generateComponent).toBeCalledTimes(3)
       expect(generator.pageGenerator.generateComponent).toBeCalledWith(
         expect.objectContaining({
           name: 'Home',
         }),
-        {
+        expect.objectContaining({
           assets: {
             identifier: null,
             mappings: {},
@@ -142,14 +151,23 @@ describe('Generic Project Generator', () => {
           },
           designLanguage: undefined,
           projectRouteDefinition: uidl.root.stateDefinitions.route,
-          projectResources: {},
+          extractedResources: {},
           mapping: {},
           skipValidation: true,
-        }
+          skipI18n: true,
+          projectComponents: expect.objectContaining({
+            ExpandableArea: expect.objectContaining({ name: 'ExpandableArea' }),
+            Modal: expect.objectContaining({ name: 'Modal' }),
+            ModalWindow: expect.objectContaining({ name: 'ModalWindow' }),
+            OneComponent: expect.objectContaining({ name: 'OneComponent' }),
+          }),
+        })
       )
 
       const routerUIDL = {
         ...uidl.root,
+        styleSetDefinitions: {},
+        propDefinitions: {},
         outputOptions: {
           fileName: strategy.router.fileName,
         },
@@ -187,7 +205,7 @@ describe('Generic Project Generator', () => {
       expect(generator.pageGenerator.generateComponent).toBeCalledTimes(3)
       expect(generator.componentGenerator.generateComponent).toBeCalledWith(
         expect.objectContaining({ name: 'ExpandableArea' }),
-        {
+        expect.objectContaining({
           assets: {
             identifier: null,
             mappings: {},
@@ -195,18 +213,27 @@ describe('Generic Project Generator', () => {
             fontsFolder: 'test/static/fonts',
             localFonts: [],
           },
-          projectResources: {},
+          extractedResources: {},
           designLanguage: undefined,
           projectRouteDefinition: uidl.root.stateDefinitions.route,
           mapping: {},
           skipValidation: true,
-        }
+          skipI18n: true,
+          projectComponents: expect.objectContaining({
+            ExpandableArea: expect.objectContaining({ name: 'ExpandableArea' }),
+            Modal: expect.objectContaining({ name: 'Modal' }),
+            ModalWindow: expect.objectContaining({ name: 'ModalWindow' }),
+            OneComponent: expect.objectContaining({ name: 'OneComponent' }),
+          }),
+        })
       )
 
       expect(generator.routerGenerator.generateComponent).toBeCalledTimes(1)
 
       const routerUIDL = {
         ...uidl.root,
+        styleSetDefinitions: {},
+        propDefinitions: {},
         outputOptions: {
           fileName: 'index',
         },

package/__tests__/resource-runtime-params.ts

@@ -0,0 +1,113 @@
+import { UIDLResourceItem } from '@teleporthq/teleport-types'
+import * as types from '@babel/types'
+import generate from '@babel/generator'
+
+import { resourceGenerator } from '../src/resource'
+
+/**
+ * A data source resource is generated as a direct `fetchData` call, and the
+ * params it declares serve two different purposes: `dataSourceId`,
+ * `dataSourceType` and `tableName` pick the utility module at generation time,
+ * while anything else is a value the handler reads out of `req.query`.
+ *
+ * Forwarding only the caller's arguments dropped the second kind. For a details
+ * page over a REST endpoint that wraps its list, that meant the handler never
+ * learned where the records were: `getStaticPaths` produced no paths and every
+ * `/page/<slug>` answered 404, with nothing in the output to point at why.
+ */
+
+const staticParam = (content: string) => ({ type: 'static' as const, content })
+
+const dataSourceResource = (params: Record<string, unknown> = {}): UIDLResourceItem =>
+  ({
+    id: 'TQ_resource',
+    name: 'fetch_data_detail',
+    path: {
+      baseUrl: staticParam('/api/data-source'),
+      route: staticParam('/92c59975/data'),
+    },
+    params: {
+      dataSourceId: staticParam('92c59975-43bc-47aa-99fd-114912138d5b'),
+      dataSourceType: staticParam('rest-api'),
+      tableName: staticParam('data'),
+      ...params,
+    },
+  } as unknown as UIDLResourceItem)
+
+const generatedCode = (resource: UIDLResourceItem): string => {
+  const { chunks } = resourceGenerator(resource, {})
+  return chunks
+    .map((chunk) => generate(chunk.content as types.Node).code)
+    .join('\n')
+    .replace(/\s+/g, ' ')
+}
+
+describe('data source resource params', () => {
+  it('forwards a runtime param the handler needs, so a wrapped list is unwrapped', () => {
+    const code = generatedCode(
+      dataSourceResource({ collectionPath: staticParam('["categories"]') })
+    )
+
+    expect(code).toContain('collectionPath: "[\\"categories\\"]"')
+    expect(code).toContain('...params')
+  })
+
+  it("lets the caller's own argument win over the baked-in default", () => {
+    const code = generatedCode(
+      dataSourceResource({ collectionPath: staticParam('["categories"]') })
+    )
+
+    // The spread has to come LAST, or a resource default would silently
+    // override what the page passed at the call site.
+    expect(code.indexOf('...params')).toBeGreaterThan(code.indexOf('collectionPath'))
+  })
+
+  it('never forwards the params that already picked the module', () => {
+    const code = generatedCode(
+      dataSourceResource({ collectionPath: staticParam('["categories"]') })
+    )
+
+    expect(code).not.toContain('dataSourceId:')
+    expect(code).not.toContain('dataSourceType:')
+    expect(code).not.toContain('tableName:')
+  })
+
+  it('passes params through untouched when there is no runtime param', () => {
+    // Every table-backed resource takes this path, and its generated code has
+    // to stay exactly what it was.
+    expect(generatedCode(dataSourceResource())).toContain('fetchData(params)')
+  })
+
+  it('skips a dynamic param, which has no value at generation time', () => {
+    const code = generatedCode(
+      dataSourceResource({
+        collectionPath: { type: 'dynamic', content: { referenceType: 'prop', id: 'path' } },
+      })
+    )
+
+    expect(code).toContain('fetchData(params)')
+  })
+})
+
+describe('structured resource params', () => {
+  it('JSON-encodes a param that is not a primitive rather than dropping it', () => {
+    // `req.query` carries everything structured as JSON already (`filters`,
+    // `sorts`, `collectionPath`), and the handlers parse it back. Skipping it
+    // would reintroduce the silent drop this whole path exists to prevent.
+    const code = generatedCode(
+      dataSourceResource({
+        collectionPath: { type: 'static', content: ['response', 'items'] },
+      } as never)
+    )
+
+    expect(code).toContain('collectionPath: "[\\"response\\",\\"items\\"]"')
+  })
+
+  it('skips a param with no value at all', () => {
+    const code = generatedCode(
+      dataSourceResource({ collectionPath: { type: 'static', content: null } } as never)
+    )
+
+    expect(code).toContain('fetchData(params)')
+  })
+})

package/__tests__/utils.ts

@@ -1,5 +1,5 @@
 import { injectFilesToPath, extractPageOptions, prepareComponentOutputOptions } from '../src/utils'
-import { UIDLStateDefinition } from '@teleporthq/teleport-types'
+import { UIDLRouteDefinitions, UIDLStateDefinition } from '@teleporthq/teleport-types'
 import { emptyFolder, folderWithFiles, createStrategyWithCommonGenerator } from './mocks'
 import { component, elementNode } from '@teleporthq/teleport-uidl-builders'
 import { GenericUtils } from '@teleporthq/teleport-shared'
@@ -140,7 +140,7 @@ describe('injectFilesToPath', () => {
 })
 
 describe('extractPageOptions', () => {
-  const routeDefinitions: UIDLStateDefinition = {
+  const routeDefinitions: UIDLRouteDefinitions = {
     type: 'string',
     defaultValue: 'home',
     values: [
@@ -203,6 +203,108 @@ describe('extractPageOptions', () => {
     expect(pageOptions.fileName).toBe('about-us')
     expect(pageOptions.componentName).toBe('AboutUs')
   })
+  it('routes the home page to / even when it brings its own address', () => {
+    // A Help Center list made the home page arrives with the address it had (`/help`).
+    // It is written as `index`, so links to it must say `/`, not `/help`.
+    const homeWithAddress: UIDLRouteDefinitions = {
+      type: 'string',
+      defaultValue: 'help-articles-list',
+      values: [{ value: 'help-articles-list', pageOptions: { navLink: '/help' } }],
+    }
+    const { pageOptions, isHomePage } = extractPageOptions(
+      homeWithAddress,
+      'help-articles-list',
+      true
+    )
+    expect(isHomePage).toBe(true)
+    expect(pageOptions.navLink).toBe('/')
+    expect(pageOptions.fileName).toBe('index')
+  })
+})
+
+/**
+ * Two admin edit pages — one over the platform `teleport_product_reviews`
+ * table, one over an author-created `product_reviews` — both arrived carrying
+ * `navLink: '/admin/product-reviews/update/[id]'`. The dedupe suffixed the
+ * route as a plain string, the second page became `.../[id]1`, and because a
+ * segment is a route parameter only when the brackets span all of it, Next
+ * refused `getStaticPaths` on it and the production build died in Vercel.
+ */
+describe('extractPageOptions — duplicate dynamic routes', () => {
+  const duplicateUpdateRoutes: UIDLRouteDefinitions = {
+    type: 'string',
+    defaultValue: 'home',
+    values: [
+      { value: 'home', pageOptions: { navLink: '/' } },
+      {
+        value: 'admin/product-reviews/update/product-reviews-update',
+        pageOptions: {
+          navLink: '/admin/product-reviews/update/[id]',
+          dynamicRouteAttribute: 'id',
+          componentName: 'ProductReviewsUpdate',
+        },
+      },
+      {
+        value: 'admin/product-reviews/update/product-reviews-update1',
+        pageOptions: {
+          navLink: '/admin/product-reviews/update/[id]',
+          dynamicRouteAttribute: 'id',
+          componentName: 'ProductReviewsUpdate',
+        },
+      },
+    ],
+  }
+
+  /**
+   * `createPageUIDL` writes each resolved `pageOptions` back into the route
+   * definition before moving to the next page, so the pages resolve in order
+   * and only one of the two can move. Replayed here so the assertion is about
+   * the pair of routes the project actually ships, not one call in isolation.
+   */
+  const resolveEveryPage = (routes: UIDLRouteDefinitions) =>
+    routes.values
+      .filter((route) => route.pageOptions)
+      .map((route) => {
+        const { pageOptions } = extractPageOptions(routes, route.value.toString(), true)
+        route.pageOptions = pageOptions
+        return pageOptions
+      })
+
+  it('moves the collision onto the static part and keeps the route parameter', () => {
+    const [, first, second] = resolveEveryPage(duplicateUpdateRoutes)
+
+    expect([first.navLink, second.navLink].sort()).toEqual([
+      '/admin/product-reviews/update/[id]',
+      '/admin/product-reviews/update1/[id]',
+    ])
+    // Both stay real dynamic pages: Next writes
+    // `pages/admin/product-reviews/update/[id].js` and `.../update1/[id].js`,
+    // and `getStaticPaths` is legal on each.
+    expect(first.fileName).toBe('[id]')
+    expect(second.fileName).toBe('[id]')
+    expect(first.dynamicRouteAttribute).toBe('id')
+    expect(second.dynamicRouteAttribute).toBe('id')
+    expect([first.componentName, second.componentName].sort()).toEqual([
+      'ProductReviewsUpdate',
+      'ProductReviewsUpdate1',
+    ])
+  })
+
+  it('still suffixes duplicate STATIC routes the way it always did', () => {
+    const duplicateListRoutes: UIDLRouteDefinitions = {
+      type: 'string',
+      defaultValue: 'home',
+      values: [
+        { value: 'home', pageOptions: { navLink: '/' } },
+        { value: 'product-reviews-list', pageOptions: { navLink: '/product-reviews-list' } },
+        { value: 'product-reviews-list1', pageOptions: { navLink: '/product-reviews-list' } },
+      ],
+    }
+
+    const { pageOptions } = extractPageOptions(duplicateListRoutes, 'product-reviews-list1', true)
+    expect(pageOptions.navLink).toBe('/product-reviews-list1')
+    expect(pageOptions.fileName).toBe('product-reviews-list1')
+  })
 })
 
 describe('prepareComponentOutputOptions', () => {

package/dist/cjs/file-handlers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file-handlers.d.ts","sourceRoot":"","sources":["../../src/file-handlers.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,aAAa,EACb,eAAe,EACf,WAAW,EAGX,aAAa,EACb,gBAAgB,EAChB,eAAe,EAMf,kBAAkB,EACnB,MAAM,4BAA4B,CAAA;AAMnC,eAAO,MAAM,UAAU,aACX,aAAa,aACZ,kBAAkB,WACpB,gBAAgB,oEAG1B,CAAA;AAED,eAAO,MAAM,eAAe,kBACX,aAAa,aACjB,kBAAkB,WACpB,gBAAgB,oEAG1B,CAAA;AAED,eAAO,MAAM,qBAAqB,SAC1B,WAAW,YACP,eAAe,aACd,kBAAkB,oEAmB9B,CAAA;AAED,eAAO,MAAM,gBAAgB,aACjB,aAAa,aACZ,kBAAkB,WACpB,gBAAgB,oEAU1B,CAAA;AAED,eAAO,MAAM,gBAAgB,SACrB,aAAa,YACT,eAAe,mBACR,kBAAkB;;;EAmCpC,CAAA;AAED,eAAO,MAAM,eAAe,SACpB,WAAW,YACP,eAAe,oBACP,gBAAgB,6BA2BnC,CAAA;AAkND,eAAO,MAAM,cAAc,QAAS,OAAO,MAAM,EAAE,MAAM,CAAC;;;;GAqBzD,CAAA;AAED,eAAO,MAAM,mBAAmB;;;;CAM/B,CAAA;AAGD,eAAO,MAAM,sBAAsB,SAC3B,WAAW,UACT,gBAAgB,CAAC,QAAQ,CAAC,KACjC,aA0BF,CAAA;AAED,eAAO,MAAM,iBAAiB,aAClB,eAAe,QACnB,WAAW,gBACH,OAAO,MAAM,EAAE,MAAM,CAAC,oBAClB,OAAO,MAAM,EAAE,MAAM,CAAC,SAmCzC,CAAA"}
+{"version":3,"file":"file-handlers.d.ts","sourceRoot":"","sources":["../../src/file-handlers.ts"],"names":[],"mappings":"AAQA,OAAO,EACL,aAAa,EACb,eAAe,EACf,WAAW,EAGX,aAAa,EACb,gBAAgB,EAChB,eAAe,EAMf,kBAAkB,EACnB,MAAM,4BAA4B,CAAA;AAMnC,eAAO,MAAM,UAAU,aACX,aAAa,aACZ,kBAAkB,WACpB,gBAAgB,oEAG1B,CAAA;AAED,eAAO,MAAM,eAAe,kBACX,aAAa,aACjB,kBAAkB,WACpB,gBAAgB,oEAG1B,CAAA;AAED,eAAO,MAAM,qBAAqB,SAC1B,WAAW,YACP,eAAe,aACd,kBAAkB,oEAoB9B,CAAA;AAED,eAAO,MAAM,gBAAgB,aACjB,aAAa,aACZ,kBAAkB,WACpB,gBAAgB,oEAU1B,CAAA;AAED,eAAO,MAAM,gBAAgB,SACrB,aAAa,YACT,eAAe,mBACR,kBAAkB;;;EAoCpC,CAAA;AAED,eAAO,MAAM,eAAe,SACpB,WAAW,YACP,eAAe,oBACP,gBAAgB,6BA2BnC,CAAA;AA0OD,eAAO,MAAM,cAAc,QAAS,OAAO,MAAM,EAAE,MAAM,CAAC;;;;GAqBzD,CAAA;AAED,eAAO,MAAM,mBAAmB;;;;CAM/B,CAAA;AAGD,eAAO,MAAM,sBAAsB,SAC3B,WAAW,UACT,gBAAgB,CAAC,QAAQ,CAAC,KACjC,aA0BF,CAAA;AAED,eAAO,MAAM,iBAAiB,aAClB,eAAe,QACnB,WAAW,gBACH,OAAO,MAAM,EAAE,MAAM,CAAC,oBAClB,OAAO,MAAM,EAAE,MAAM,CAAC,SAmCzC,CAAA"}

package/dist/cjs/file-handlers.js

@@ -76,6 +76,7 @@ var createComponentModule = function (uidl, strategy, generator) { return __awai
             localDependenciesPrefix: componentLocalDependenciesPrefix,
             strategy: strategy,
             moduleComponents: uidl.components,
+            extractedResources: {},
         };
         root.outputOptions = root.outputOptions || {};
         root.outputOptions.fileName = 'components.module';
@@ -106,6 +107,7 @@ var createRouterFile = function (root, strategy, routerGenerator) { return __awa
                     strategy: strategy,
                     isRootComponent: true,
                     designLanguage: root === null || root === void 0 ? void 0 : root.designLanguage,
+                    extractedResources: {},
                 };
                 if (projectStyleSheet) {
                     options = __assign(__assign({}, options), { projectStyleSet: {
@@ -162,6 +164,12 @@ var createHTMLEntryFileChunks = function (uidl, options) {
     var bodyNode = teleport_plugin_common_1.HASTBuilders.createHTMLNode('body');
     teleport_plugin_common_1.HASTUtils.addChildNode(htmlNode, headNode);
     teleport_plugin_common_1.HASTUtils.addChildNode(htmlNode, bodyNode);
+    // First in <head>, ahead of every script it guards.
+    if (teleport_shared_1.InlineScriptErrorGuard.documentRunsProjectScripts(uidl.globals)) {
+        var guardTag = teleport_plugin_common_1.HASTBuilders.createHTMLNode('script');
+        teleport_plugin_common_1.HASTUtils.addTextNode(guardTag, teleport_shared_1.InlineScriptErrorGuard.INLINE_SCRIPT_ERROR_GUARD);
+        teleport_plugin_common_1.HASTUtils.addChildNode(headNode, guardTag);
+    }
     // Vue and React use a standard <div id="app"/> in the body tag.
     // Nuxt has an internal templating so requires an override
     if (appRootOverride) {
@@ -218,6 +226,20 @@ var createHTMLEntryFileChunks = function (uidl, options) {
         });
         teleport_plugin_common_1.HASTUtils.addChildNode(headNode, metaTag);
     });
+    // Preconnect hints first: they only help if the browser sees them BEFORE the
+    // stylesheet link that triggers the two-hop font fetch. Mirrors the JSX head
+    // builder in teleport-plugin-common, and shares its resolver.
+    teleport_shared_1.FontPreconnect.resolveFontPreconnectHints(assets.map(function (asset) {
+        return 'path' in asset ? teleport_shared_1.UIDLUtils.prefixAssetsPath(asset.path, options.assets) : undefined;
+    })).forEach(function (hint) {
+        var preconnectTag = teleport_plugin_common_1.HASTBuilders.createHTMLNode('link');
+        teleport_plugin_common_1.HASTUtils.addAttributeToNode(preconnectTag, 'rel', 'preconnect');
+        teleport_plugin_common_1.HASTUtils.addAttributeToNode(preconnectTag, 'href', hint.href);
+        if (hint.crossorigin) {
+            teleport_plugin_common_1.HASTUtils.addBooleanAttributeToNode(preconnectTag, 'crossorigin');
+        }
+        teleport_plugin_common_1.HASTUtils.addChildNode(headNode, preconnectTag);
+    });
     assets.forEach(function (asset) {
         var assetPath;
         if ('path' in asset) {