
package com.smartgwt.client.docs;

/**
 * <h3>React JSX Integration</h3>
 * Smart GWT ships a React 18 wrapper layer that lets every Smart GWT class be created
 *  and composed as a React component &mdash; <code>SC.ListGrid</code>,
 *  <code>SC.DynamicForm</code>, <code>SC.Button</code>, etc. &mdash; while keeping the
 *  underlying Smart GWT widget in charge of rendering, layout, sizing, and event handling.
 *  JSX is the markup; Smart GWT is the framework.
 *  <P>
 *  <h3>JSX-valued properties</h3>
 * Any Smart GWT property that accepts a string of HTML (for example {@link
 * com.smartgwt.client.widgets.Canvas#getContents Canvas.contents}
 * or {@link com.smartgwt.client.widgets.Hover#getContents Hover.contents}) also accepts a React
 * element value:
 *  <pre>
 *    &lt;SC.Canvas contents={&lt;MyHeader title="Hello"/&gt;}/&gt;
 *  </pre>
 *  Two rendering modes are supported automatically based on the JSX value's content:
 *  <ul>
 *  <li><b>SSR mode</b> (the default for static JSX) &mdash; the JSX is rendered once via
 *  React's static markup renderer and the resulting HTML is handed to the Smart GWT
 *  setter.  Cheap, no React runtime in the widget, no lifecycle.</li>
 *  <li><b>Root mode</b> (used when the JSX value references live React state or contains
 *  other Smart GWT React wrappers) &mdash; the wrapper writes a placeholder
 *  <code>&lt;div&gt;</code> via the setter, then mounts a React 18 root inside the
 *  placeholder.  Subsequent updates re-render through that root, so React state and JSX
 *  children flow through normally.</li>
 *  </ul>
 *  Mode is detected automatically; application code never selects.
 *  <P>
 *  <h3>JSX cell rendering</h3>
 * {@link com.smartgwt.client.widgets.grid.ListGridField#getCellTemplate
 * ListGridField.cellTemplate} accepts a JSX-returning function:
 *  <pre>
 *    &lt;SC.ListGrid&gt;
 *        &lt;fields&gt;
 *            &lt;field name="status" cellTemplate={record =&gt;
 *                &lt;StatusBadge state={record.state}/&gt;
 *            }/&gt;
 *        &lt;/fields&gt;
 *    &lt;/SC.ListGrid&gt;
 *  </pre>
 *  Each rendered cell mounts its own per-cell React portal inside the body's
 *  <code>&lt;td&gt;</code>, reconciled against the grid's live cell-geometry on render,
 *  resize, freeze/unfreeze, and column reorder.  Per-cell portals are created and torn
 *  down alongside the grid's normal cell lifecycle &mdash; no manual cleanup required.
 *  <P>
 *  <h3>Dynamic Templates in JSX</h3>
 * The same &#123;expr&#125; {@link com.smartgwt.client.docs.DynamicTemplates dynamic template}
 * syntax used in
 *  plain Smart GWT property values also works inside JSX string props.  When the wrapper
 *  is rendered inside a React tree, &#123;expr&#125; placeholders bind to React state
 *  (resolved via  SC.useRuleScope) instead of the rules-engine ruleScope, so the
 *  same markup is portable between React and non-React builds.  React state changes
 *  propagate to the Smart GWT widget through the normal setter pipeline, with no manual
 *  setter calls.
 *  <P>
 *  <h3>Bridging rule scope and React state</h3>
 *   SC.useRuleScope is a React hook that exposes the surrounding Smart GWT
 *  ruleScope as a React state slice for use in JSX children.   SC.ContextBridge
 *  propagates React context across the Smart GWT-to-React-and-back boundary that
 *  Root-mode portals introduce, so React providers in the host application remain visible
 *  to JSX rendered inside a Smart GWT widget's contents.
 *  <P>
 *  <h3>Defining custom React classes</h3>
 *   SC.defineClass registers a React component as a first-class Smart GWT class,
 *  usable in JSX as <code>&lt;SC.MyClass.../&gt;</code> and discoverable to the Smart GWT
 *  generator for typed prop declarations.  Use this to factor an application's own widget
 *  abstractions consistently with Smart GWT's own wrapper layer.
 *  <P>
 *  <h3>Performance</h3>
 *  All optimisations live in core Smart GWT (suppressRedraw windows, the
 * {@link com.smartgwt.client.widgets.grid.GridRenderer#_cellsRendered
 * GridRenderer._cellsRendered()} hook, scID error placeholders, ResizeObserver wiring
 *  for external content, the &#123;expr&#125; template engine itself), so any external DOM
 *  manager &mdash; React, Web Components, vanilla JS, Angular wrappers &mdash; benefits
 *  without per-host duplication.  React-specific code paths are restricted to call sites
 *  that must invoke React APIs directly.
 */
public interface ReactJSXIntegration {
}
