@teleporthq/teleport-uidl-resolver 0.43.53 → 0.43.57

package/__tests__/html-nesting/diagnostics.ts

@@ -0,0 +1,95 @@
+import { GeneratorOptions } from '@teleporthq/teleport-types'
+import { resolveHtmlNesting } from '../../src/resolvers/html-nesting'
+import { component, element, text } from './mocks'
+
+const NO_OPTIONS: GeneratorOptions = {}
+
+let warnSpy: jest.SpyInstance
+
+const warnings = (): string[] => warnSpy.mock.calls.map((call) => String(call[0]))
+
+beforeEach(() => {
+  warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => undefined)
+})
+
+afterEach(() => {
+  warnSpy.mockRestore()
+})
+
+describe('resolveHtmlNesting — nesting that has no lossless repair', () => {
+  it('reports a nested anchor and leaves both in place', () => {
+    const inner = element('a', [text('Details')])
+    const outer = element('a', [element('div', [inner])])
+
+    resolveHtmlNesting(component(outer, 'Product-Card'), NO_OPTIONS)
+
+    expect(inner.content.elementType).toBe('a')
+    expect(warnings()).toEqual([expect.stringContaining('<a> nested inside another <a>')])
+    expect(warnings()[0]).toContain('Product-Card')
+  })
+
+  it('forgets an anchor once a scope boundary hides it from the parser', () => {
+    const inner = element('a', [text('Details')])
+    const outer = element('a', [element('table', [element('td', [inner])])])
+
+    resolveHtmlNesting(component(outer), NO_OPTIONS)
+
+    expect(warnings().filter((message) => message.includes('nested inside another <a>'))).toEqual(
+      []
+    )
+  })
+
+  it('reports a nested form', () => {
+    const outer = element('form', [element('div', [element('form', [])])])
+
+    resolveHtmlNesting(component(outer), NO_OPTIONS)
+
+    expect(warnings()).toEqual([expect.stringContaining('<form> nested inside another <form>')])
+  })
+
+  it('reports content the parser would hoist out of a table', () => {
+    const table = element('table', [element('div', [])])
+
+    resolveHtmlNesting(component(table), NO_OPTIONS)
+
+    expect(warnings()).toEqual([expect.stringContaining('<div> is not valid content for <table>')])
+  })
+
+  it('sees through a component wrapper when checking table content', () => {
+    const table = element('table', [element('Repeater', [element('tr', [])])])
+
+    resolveHtmlNesting(component(table), NO_OPTIONS)
+
+    expect(warnings()).toEqual([expect.stringContaining('<tr> is not valid content for <table>')])
+  })
+
+  it('accepts a well-formed table', () => {
+    const table = element('table', [
+      element('tbody', [element('tr', [element('td', [text('7')])])]),
+    ])
+
+    resolveHtmlNesting(component(table), NO_OPTIONS)
+
+    expect(warnings()).toEqual([])
+  })
+
+  it('reports a heading inside a heading', () => {
+    const heading = element('h2', [element('h3', [text('Sub')])])
+
+    resolveHtmlNesting(component(heading), NO_OPTIONS)
+
+    expect(warnings()).toEqual([expect.stringContaining('<h3> nested inside <h2>')])
+  })
+
+  it('says nothing about markup that parses as written', () => {
+    const section = element('section', [
+      element('h2', [text('Title')]),
+      element('p', [element('a', [element('span', [text('link')])])]),
+      element('button', [element('span', [text('Buy')])]),
+    ])
+
+    resolveHtmlNesting(component(section), NO_OPTIONS)
+
+    expect(warnings()).toEqual([])
+  })
+})

package/__tests__/html-nesting/mocks.ts

@@ -0,0 +1,66 @@
+import {
+  ComponentUIDL,
+  GeneratorOptions,
+  UIDLElementNode,
+  UIDLNode,
+  UIDLStyleSetDefinition,
+  UIDLStyleSheetContent,
+} from '@teleporthq/teleport-types'
+
+/**
+ * The nesting resolver runs on an ALREADY MAPPED tree, so these mocks are
+ * written with the final tag in `elementType` — exactly the shape
+ * `utils.resolveNode` leaves behind.
+ */
+export const element = (
+  elementType: string,
+  children: UIDLNode[] = [],
+  content: Partial<UIDLElementNode['content']> = {}
+): UIDLElementNode => ({
+  type: 'element',
+  content: {
+    elementType,
+    children,
+    ...content,
+  },
+})
+
+export const text = (content: string): UIDLNode => ({ type: 'static', content })
+
+export const component = (node: UIDLElementNode, name = 'Homepage'): ComponentUIDL =>
+  ({ name, node } as ComponentUIDL)
+
+/** A node-level `referencedStyles` entry pointing at a project style set. */
+export const referencingProjectStyle = (
+  referenceId: string
+): Partial<UIDLElementNode['content']> => ({
+  referencedStyles: {
+    [referenceId]: {
+      type: 'style-map',
+      content: { mapType: 'project-referenced', referenceId },
+    },
+  },
+})
+
+export const optionsWithProjectStyles = (
+  styleSetDefinitions: Record<string, UIDLStyleSetDefinition>
+): GeneratorOptions => ({
+  projectStyleSet: { styleSetDefinitions, fileName: 'style', path: '.' },
+})
+
+export const staticStyleSet = (declarations: Record<string, string>): UIDLStyleSetDefinition => {
+  const content: Record<string, UIDLStyleSheetContent> = {}
+  Object.keys(declarations).forEach((property) => {
+    content[property] = { type: 'static', content: declarations[property] }
+  })
+  return { type: 'reusable-project-style-map', content }
+}
+
+/** The `elementType` of every element in the tree, in depth-first order. */
+export const tagsOf = (node: UIDLNode, tags: string[] = []): string[] => {
+  if (node.type === 'element') {
+    tags.push(node.content.elementType)
+    ;(node.content.children || []).forEach((child) => tagsOf(child, tags))
+  }
+  return tags
+}

package/__tests__/html-nesting/paragraph-repair.ts

@@ -0,0 +1,251 @@
+import { GeneratorOptions, UIDLElementNode } from '@teleporthq/teleport-types'
+import { resolveHtmlNesting } from '../../src/resolvers/html-nesting'
+import {
+  component,
+  element,
+  optionsWithProjectStyles,
+  referencingProjectStyle,
+  staticStyleSet,
+  tagsOf,
+  text,
+} from './mocks'
+
+const NO_OPTIONS: GeneratorOptions = {}
+
+// `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('resolveHtmlNesting — paragraph content', () => {
+  it('retags a wrapper <div> reached through a framework component', () => {
+    // The shape that shipped: <p>… <Link><a><div><span>Privacy Policy</span>.
+    const wrapper = element('div', [element('span', [text('Privacy Policy')])])
+    const paragraph = element('p', [
+      element('span', [text('We promise only joy, no junk. See our ')]),
+      element('Link', [element('a', [wrapper])]),
+      element('span', [text('.')]),
+    ])
+
+    resolveHtmlNesting(component(paragraph), NO_OPTIONS)
+
+    expect(paragraph.content.elementType).toBe('p')
+    expect(wrapper.content.elementType).toBe('span')
+    expect(tagsOf(paragraph)).toEqual(['p', 'span', 'Link', 'a', 'span', 'span', 'span'])
+  })
+
+  it('restates the block display the retagged wrapper loses with its tag', () => {
+    const wrapper = element('div', [element('span', [text('Read more')])])
+    const paragraph = element('p', [wrapper])
+
+    resolveHtmlNesting(component(paragraph), NO_OPTIONS)
+
+    expect(wrapper.content.style).toEqual({ display: { type: 'static', content: 'block' } })
+  })
+
+  it('leaves the display alone when the node already declares one', () => {
+    const wrapper = element('div', [], {
+      style: { display: { type: 'static', content: 'flex' } },
+    })
+    const paragraph = element('p', [wrapper])
+
+    resolveHtmlNesting(component(paragraph), NO_OPTIONS)
+
+    expect(wrapper.content.elementType).toBe('span')
+    expect(wrapper.content.style.display).toEqual({ type: 'static', content: 'flex' })
+  })
+
+  it('leaves the display alone when a project class declares one', () => {
+    const wrapper = element('div', [], referencingProjectStyle('card-row'))
+    const paragraph = element('p', [wrapper])
+
+    resolveHtmlNesting(
+      component(paragraph),
+      optionsWithProjectStyles({ 'card-row': staticStyleSet({ display: 'flex' }) })
+    )
+
+    expect(wrapper.content.elementType).toBe('span')
+    expect(wrapper.content.style).toBeUndefined()
+  })
+
+  it('adds the display when the project class it references declares none', () => {
+    const wrapper = element('div', [], referencingProjectStyle('card-row'))
+    const paragraph = element('p', [wrapper])
+
+    resolveHtmlNesting(
+      component(paragraph),
+      optionsWithProjectStyles({ 'card-row': staticStyleSet({ color: 'red' }) })
+    )
+
+    expect(wrapper.content.style).toEqual({ display: { type: 'static', content: 'block' } })
+  })
+
+  it('does not guess a display when the referenced style set cannot be read', () => {
+    const wrapper = element('div', [], referencingProjectStyle('card-row'))
+    const paragraph = element('p', [wrapper])
+
+    resolveHtmlNesting(component(paragraph), NO_OPTIONS)
+
+    expect(wrapper.content.elementType).toBe('span')
+    expect(wrapper.content.style).toBeUndefined()
+  })
+
+  it('retags every offending wrapper, however deep', () => {
+    const outer = element('div', [])
+    const inner = element('div', [])
+    outer.content.children = [element('span', [inner])]
+    const paragraph = element('p', [outer])
+
+    resolveHtmlNesting(component(paragraph), NO_OPTIONS)
+
+    expect(outer.content.elementType).toBe('span')
+    expect(inner.content.elementType).toBe('span')
+  })
+
+  it('demotes the paragraph when an offender carries meaning of its own', () => {
+    const list = element('ul', [element('li', [text('One')])])
+    const paragraph = element('p', [element('span', [text('Sizes:')]), list], {
+      semanticType: 'p',
+    })
+
+    resolveHtmlNesting(component(paragraph), NO_OPTIONS)
+
+    expect(paragraph.content.elementType).toBe('div')
+    expect(paragraph.content.semanticType).toBe('div')
+    expect(list.content.elementType).toBe('ul')
+  })
+
+  it('restores the paragraph block margins the demotion drops', () => {
+    const paragraph = element('p', [element('h3', [text('Heading')])])
+
+    resolveHtmlNesting(component(paragraph), NO_OPTIONS)
+
+    expect(paragraph.content.style).toEqual({
+      marginTop: { type: 'static', content: '1em' },
+      marginBottom: { type: 'static', content: '1em' },
+    })
+  })
+
+  it('keeps the authored spacing instead of restoring the browser default', () => {
+    const paragraph = element('p', [element('h3', [text('Heading')])], {
+      ...referencingProjectStyle('newsletter-privacy'),
+    })
+
+    resolveHtmlNesting(
+      component(paragraph),
+      optionsWithProjectStyles({ 'newsletter-privacy': staticStyleSet({ margin: '0' }) })
+    )
+
+    expect(paragraph.content.elementType).toBe('div')
+    expect(paragraph.content.style).toBeUndefined()
+  })
+
+  it('demotes rather than retags when the paragraph holds both kinds of offender', () => {
+    const wrapper = element('div', [])
+    const paragraph = element('p', [wrapper, element('table', [])])
+
+    resolveHtmlNesting(component(paragraph), NO_OPTIONS)
+
+    expect(paragraph.content.elementType).toBe('div')
+    expect(wrapper.content.elementType).toBe('div')
+  })
+
+  it('repairs a nested paragraph on its own terms', () => {
+    const wrapper = element('div', [])
+    const inner = element('p', [wrapper])
+    const outer = element('p', [inner])
+
+    resolveHtmlNesting(component(outer), NO_OPTIONS)
+
+    expect(outer.content.elementType).toBe('div')
+    expect(inner.content.elementType).toBe('p')
+    expect(wrapper.content.elementType).toBe('span')
+  })
+
+  it('leaves a paragraph whose content is already valid untouched', () => {
+    const paragraph = element('p', [
+      element('span', [text('See our ')]),
+      element('a', [element('span', [text('terms')])]),
+    ])
+
+    resolveHtmlNesting(component(paragraph), NO_OPTIONS)
+
+    expect(tagsOf(paragraph)).toEqual(['p', 'span', 'a', 'span'])
+    expect(warnSpy).not.toHaveBeenCalled()
+  })
+
+  it('ignores a wrapper that a <button> puts out of paragraph scope', () => {
+    // `<p><button><div/></button></p>` parses as written — the parser only
+    // closes a paragraph that is in BUTTON scope.
+    const wrapper = element('div', [])
+    const paragraph = element('p', [element('button', [wrapper])])
+
+    resolveHtmlNesting(component(paragraph), NO_OPTIONS)
+
+    expect(paragraph.content.elementType).toBe('p')
+    expect(wrapper.content.elementType).toBe('div')
+  })
+
+  it('does not descend into <svg>, where the HTML content model does not apply', () => {
+    const svgChild = element('title', [text('Arrow')])
+    const paragraph = element('p', [element('svg', [svgChild])])
+
+    resolveHtmlNesting(component(paragraph), NO_OPTIONS)
+
+    expect(paragraph.content.elementType).toBe('p')
+    expect(svgChild.content.elementType).toBe('title')
+    expect(warnSpy).not.toHaveBeenCalled()
+  })
+
+  it('repairs render branches of a CMS repeater against the enclosing paragraph', () => {
+    const listWrapper = element('div', [])
+    const emptyWrapper = element('div', [])
+    const paragraph: UIDLElementNode = element('p', [
+      {
+        type: 'cms-list-repeater',
+        content: {
+          nodes: { list: listWrapper, empty: emptyWrapper },
+        },
+      } as never,
+    ])
+
+    resolveHtmlNesting(component(paragraph), NO_OPTIONS)
+
+    expect(listWrapper.content.elementType).toBe('span')
+    expect(emptyWrapper.content.elementType).toBe('span')
+  })
+
+  it('inspects an element passed as an attribute on its own', () => {
+    const wrapper = element('div', [])
+    const slotParagraph = element('p', [wrapper])
+    const host = element('p', [], { attrs: { renderItem: slotParagraph } })
+
+    resolveHtmlNesting(component(host), NO_OPTIONS)
+
+    // The attribute tree is repaired against ITS OWN paragraph, and the host
+    // paragraph is not blamed for content it never renders inline.
+    expect(wrapper.content.elementType).toBe('span')
+    expect(slotParagraph.content.elementType).toBe('p')
+    expect(host.content.elementType).toBe('p')
+  })
+
+  it('walks element trees held in prop definitions', () => {
+    const wrapper = element('div', [])
+    const paragraph = element('p', [wrapper])
+    const uidl = component(element('div', []))
+    uidl.propDefinitions = {
+      header: { type: 'element', defaultValue: paragraph },
+    } as never
+
+    resolveHtmlNesting(uidl, NO_OPTIONS)
+
+    expect(wrapper.content.elementType).toBe('span')
+  })
+})

package/dist/cjs/resolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../../src/resolver.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,aAAa,EACb,WAAW,EACX,OAAO,EACP,gBAAgB,EAEjB,MAAM,4BAA4B,CAAA;AAOnC;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,QAAQ;IAC3B,OAAO,CAAC,OAAO,CAMd;gBAEW,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,EAAE;IAQlC,UAAU,CAAC,OAAO,EAAE,OAAO;IAI3B,WAAW,CAAC,KAAK,EAAE,aAAa,EAAE,OAAO,GAAE,gBAA6C;IAyCxF,cAAc,CACnB,OAAO,EAAE,WAAW,EACpB,OAAO,GAAE,gBAA6C;CAYzD"}
+{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../../src/resolver.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,aAAa,EACb,WAAW,EACX,OAAO,EACP,gBAAgB,EAEjB,MAAM,4BAA4B,CAAA;AAQnC;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,QAAQ;IAC3B,OAAO,CAAC,OAAO,CAMd;gBAEW,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,EAAE;IAQlC,UAAU,CAAC,OAAO,EAAE,OAAO;IAI3B,WAAW,CAAC,KAAK,EAAE,aAAa,EAAE,OAAO,GAAE,gBAA6C;IAkDxF,cAAc,CACnB,OAAO,EAAE,WAAW,EACpB,OAAO,GAAE,gBAA6C;CAYzD"}

package/dist/cjs/resolver.js

@@ -41,6 +41,7 @@ var style_set_definitions_1 = require("./resolvers/style-set-definitions");
 var referenced_styles_1 = require("./resolvers/referenced-styles");
 var embed_node_1 = require("./resolvers/embed-node");
 var unbound_expressions_1 = require("./resolvers/unbound-expressions");
+var html_nesting_1 = require("./resolvers/html-nesting");
 /**
  * The resolver takes the input UIDL and converts all the abstract node types into
  * concrete node types, based on the mappings you provide
@@ -81,6 +82,14 @@ var Resolver = /** @class */ (function () {
         (0, embed_node_1.resolveHtmlNode)(uidl, newOptions);
         utils.resolveNode(uidl.node, newOptions);
         utils.resolveNodeInPropDefinitions(uidl, newOptions);
+        // Element types are concrete HTML tags from here on, which is the earliest
+        // point at which the markup can be checked against the HTML content model.
+        // Nesting the parser refuses to keep (a `<div>` inside a `<p>`, a `<form>`
+        // inside a `<form>`) makes the served HTML parse into a different tree than
+        // the one that was rendered, and React then fails to hydrate the page.
+        if (!newOptions.skipHtmlNestingResolver) {
+            (0, html_nesting_1.resolveHtmlNesting)(uidl, newOptions);
+        }
         // Guard against `expr` nodes that reference an out-of-scope identifier
         // (e.g. an orphaned `<option>{{ cat.name }}</option>` whose repeater was
         // never generated). Left untouched they compile to `ReferenceError`s that

package/dist/cjs/resolver.js.map

@@ -1 +1 @@
-{"version":3,"file":"resolver.js","sourceRoot":"","sources":["../../src/resolver.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"resolver.js","sourceRoot":"","sources":["../../src/resolver.ts"],"names":[],"mappings":"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"}

package/dist/cjs/resolvers/html-nesting/diagnostics.d.ts

@@ -0,0 +1,23 @@
+import { UIDLElementNode } from '@teleporthq/teleport-types';
+import { NestingContext, NestingResolverContext } from './types';
+/**
+ * The DOM-restructuring nestings that have no lossless repair.
+ *
+ * Every one of them either removes an element the page needs (`<form>` inside
+ * `<form>` — the inner one is never created) or moves it somewhere else
+ * (`<div>` inside `<tbody>` is foster-parented out of the table). Renaming a
+ * tag to make the markup parse would silently drop the behaviour the element
+ * was added for, so these are reported rather than rewritten: the fix belongs
+ * in whatever produced the tree.
+ *
+ * Paragraph content is deliberately absent — it IS repairable losslessly, and
+ * `paragraph-repair` handles it.
+ */
+export declare const reportUnrepairableNesting: (node: UIDLElementNode, tag: string, nesting: NestingContext, context: NestingResolverContext) => void;
+/**
+ * `ancestorInfo` bookkeeping for the tags whose duplicates the parser rejects.
+ * `<a>`, `<button>` and `<nobr>` stop counting past a scope boundary (a table
+ * cell, an `<object>`, …); the form pointer has no such boundary.
+ */
+export declare const nextOpenSelfNestingTags: (tag: string, current: Record<string, boolean>) => Record<string, boolean>;
+//# sourceMappingURL=diagnostics.d.ts.map

package/dist/cjs/resolvers/html-nesting/diagnostics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics.d.ts","sourceRoot":"","sources":["../../../../src/resolvers/html-nesting/diagnostics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAA;AAE5D,OAAO,EAAE,cAAc,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAmBhE;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,yBAAyB,SAC9B,eAAe,OAChB,MAAM,WACF,cAAc,WACd,sBAAsB,KAC9B,IA0BF,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,QAC7B,MAAM,WACF,OAAO,MAAM,EAAE,OAAO,CAAC,KAC/B,OAAO,MAAM,EAAE,OAAO,CAYxB,CAAA"}

package/dist/cjs/resolvers/html-nesting/diagnostics.js

@@ -0,0 +1,77 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nextOpenSelfNestingTags = exports.reportUnrepairableNesting = void 0;
+var teleport_shared_1 = require("@teleporthq/teleport-shared");
+var SELF_NESTING_TAGS = teleport_shared_1.HtmlContentModel.SELF_NESTING_TAGS, acceptsChildTag = teleport_shared_1.HtmlContentModel.acceptsChildTag, isHeadingTag = teleport_shared_1.HtmlContentModel.isHeadingTag, endsInlineScope = teleport_shared_1.HtmlContentModel.endsInlineScope;
+var HYDRATION_DOC = 'nextjs.org/docs/messages/react-hydration-error';
+var warn = function (context, message) {
+    console.warn("[html-nesting] ".concat(context.componentName, ": ").concat(message, " (see ").concat(HYDRATION_DOC, ")"));
+};
+/**
+ * `<div>` alone rarely tells anyone which node to open. The UIDL `name` is the
+ * element's identity in the editor, so it is quoted whenever it adds anything.
+ */
+var describeElement = function (node, tag) {
+    var name = node.content.name;
+    return name && name !== tag ? "<".concat(tag, "> \"").concat(name, "\"") : "<".concat(tag, ">");
+};
+/**
+ * The DOM-restructuring nestings that have no lossless repair.
+ *
+ * Every one of them either removes an element the page needs (`<form>` inside
+ * `<form>` — the inner one is never created) or moves it somewhere else
+ * (`<div>` inside `<tbody>` is foster-parented out of the table). Renaming a
+ * tag to make the markup parse would silently drop the behaviour the element
+ * was added for, so these are reported rather than rewritten: the fix belongs
+ * in whatever produced the tree.
+ *
+ * Paragraph content is deliberately absent — it IS repairable losslessly, and
+ * `paragraph-repair` handles it.
+ */
+var reportUnrepairableNesting = function (node, tag, nesting, context) {
+    var element = describeElement(node, tag);
+    if (SELF_NESTING_TAGS.has(tag) && nesting.openSelfNestingTags[tag]) {
+        warn(context, "".concat(element, " nested inside another <").concat(tag, ">. The parser refuses to nest them and ") +
+            "closes or drops one of the two");
+    }
+    var parentTag = nesting.parentTag;
+    if (!parentTag) {
+        return;
+    }
+    if (!acceptsChildTag(parentTag, tag)) {
+        warn(context, "".concat(element, " is not valid content for <").concat(parentTag, ">. The parser moves or drops it"));
+    }
+    if (isHeadingTag(tag) && isHeadingTag(parentTag)) {
+        warn(context, "".concat(element, " nested inside <").concat(parentTag, ">. The parser closes the outer heading"));
+    }
+};
+exports.reportUnrepairableNesting = reportUnrepairableNesting;
+/**
+ * `ancestorInfo` bookkeeping for the tags whose duplicates the parser rejects.
+ * `<a>`, `<button>` and `<nobr>` stop counting past a scope boundary (a table
+ * cell, an `<object>`, …); the form pointer has no such boundary.
+ */
+var nextOpenSelfNestingTags = function (tag, current) {
+    var _a;
+    var next = current;
+    if (endsInlineScope(tag)) {
+        next = __assign(__assign({}, next), { a: false, button: false, nobr: false });
+    }
+    if (SELF_NESTING_TAGS.has(tag)) {
+        next = __assign(__assign({}, next), (_a = {}, _a[tag] = true, _a));
+    }
+    return next;
+};
+exports.nextOpenSelfNestingTags = nextOpenSelfNestingTags;
+//# sourceMappingURL=diagnostics.js.map

package/dist/cjs/resolvers/html-nesting/diagnostics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics.js","sourceRoot":"","sources":["../../../../src/resolvers/html-nesting/diagnostics.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AACA,+DAA8D;AAGtD,IAAA,iBAAiB,GAAqD,kCAAgB,kBAArE,EAAE,eAAe,GAAoC,kCAAgB,gBAApD,EAAE,YAAY,GAAsB,kCAAgB,aAAtC,EAAE,eAAe,GAAK,kCAAgB,gBAArB,CAAqB;AAE9F,IAAM,aAAa,GAAG,gDAAgD,CAAA;AAEtE,IAAM,IAAI,GAAG,UAAC,OAA+B,EAAE,OAAe;IAC5D,OAAO,CAAC,IAAI,CAAC,yBAAkB,OAAO,CAAC,aAAa,eAAK,OAAO,mBAAS,aAAa,MAAG,CAAC,CAAA;AAC5F,CAAC,CAAA;AAED;;;GAGG;AACH,IAAM,eAAe,GAAG,UAAC,IAAqB,EAAE,GAAW;IACjD,IAAA,IAAI,GAAK,IAAI,CAAC,OAAO,KAAjB,CAAiB;IAC7B,OAAO,IAAI,IAAI,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC,WAAI,GAAG,iBAAM,IAAI,OAAG,CAAC,CAAC,CAAC,WAAI,GAAG,MAAG,CAAA;AACjE,CAAC,CAAA;AAED;;;;;;;;;;;;GAYG;AACI,IAAM,yBAAyB,GAAG,UACvC,IAAqB,EACrB,GAAW,EACX,OAAuB,EACvB,OAA+B;IAE/B,IAAM,OAAO,GAAG,eAAe,CAAC,IAAI,EAAE,GAAG,CAAC,CAAA;IAE1C,IAAI,iBAAiB,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,OAAO,CAAC,mBAAmB,CAAC,GAAG,CAAC,EAAE;QAClE,IAAI,CACF,OAAO,EACP,UAAG,OAAO,qCAA2B,GAAG,4CAAyC;YAC/E,gCAAgC,CACnC,CAAA;KACF;IAEO,IAAA,SAAS,GAAK,OAAO,UAAZ,CAAY;IAC7B,IAAI,CAAC,SAAS,EAAE;QACd,OAAM;KACP;IAED,IAAI,CAAC,eAAe,CAAC,SAAS,EAAE,GAAG,CAAC,EAAE;QACpC,IAAI,CACF,OAAO,EACP,UAAG,OAAO,wCAA8B,SAAS,oCAAiC,CACnF,CAAA;KACF;IAED,IAAI,YAAY,CAAC,GAAG,CAAC,IAAI,YAAY,CAAC,SAAS,CAAC,EAAE;QAChD,IAAI,CAAC,OAAO,EAAE,UAAG,OAAO,6BAAmB,SAAS,2CAAwC,CAAC,CAAA;KAC9F;AACH,CAAC,CAAA;AA/BY,QAAA,yBAAyB,6BA+BrC;AAED;;;;GAIG;AACI,IAAM,uBAAuB,GAAG,UACrC,GAAW,EACX,OAAgC;;IAEhC,IAAI,IAAI,GAAG,OAAO,CAAA;IAElB,IAAI,eAAe,CAAC,GAAG,CAAC,EAAE;QACxB,IAAI,yBAAQ,IAAI,KAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,GAAE,CAAA;KACzD;IAED,IAAI,iBAAiB,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;QAC9B,IAAI,yBAAQ,IAAI,gBAAG,GAAG,IAAG,IAAI,MAAE,CAAA;KAChC;IAED,OAAO,IAAI,CAAA;AACb,CAAC,CAAA;AAfY,QAAA,uBAAuB,2BAenC"}

package/dist/cjs/resolvers/html-nesting/index.d.ts

@@ -0,0 +1,33 @@
+import { ComponentUIDL, GeneratorOptions } from '@teleporthq/teleport-types';
+/**
+ * Makes the generated markup parse into the tree it was rendered as.
+ *
+ * Server-rendered HTML is re-parsed by the browser before React hydrates it,
+ * and a handful of tag combinations make the parser rewrite the tree — closing
+ * a `<p>` early, hoisting a `<div>` out of a `<table>`, dropping a nested
+ * `<form>`. Whatever React rendered on the server no longer matches the DOM it
+ * finds on the client, hydration fails, and the page is silently re-rendered
+ * from scratch: styles flash, server-computed content is thrown away, and the
+ * console fills with "Hydration failed because the initial UI does not match
+ * what was rendered on the server".
+ *
+ * The pass runs after the element mapping, so every `elementType` is already
+ * the tag that will be emitted (`text`+`p` has become `p`, a navlink has become
+ * `Link` wrapping an `a`). It walks the resolved tree with the same
+ * `ancestorInfo` bookkeeping react-dom's `validateDOMNesting` uses, so it flags
+ * exactly what React would have flagged at runtime — only early enough to do
+ * something about it.
+ *
+ * Paragraph content is repaired in place, because a rename is enough and costs
+ * nothing (see `paragraph-repair`). The rest is reported: renaming a `<form>`
+ * or a `<td>` to make it parse would throw away the behaviour it was added for.
+ *
+ * Element types that are not HTML tags — `Link`, `Repeater`, `Fragment`,
+ * `TqMotion`, custom elements — have no content model of their own. They are
+ * walked THROUGH rather than treated as a boundary: `<p><Link><a><div>` is the
+ * shape that shipped, and only a walk that ignores the component in the middle
+ * can see it. Component INSTANCES are a real boundary and are not walked at
+ * all; each one is resolved as its own UIDL.
+ */
+export declare const resolveHtmlNesting: (uidl: ComponentUIDL, options: GeneratorOptions) => void;
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/resolvers/html-nesting/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/resolvers/html-nesting/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,gBAAgB,EAGjB,MAAM,4BAA4B,CAAA;AAkBnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,kBAAkB,SAAU,aAAa,WAAW,gBAAgB,KAAG,IAiBnF,CAAA"}