jj 2.5.0 → 2.6.0

package/lib/helpers.js.map

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

package/lib/index.d.ts

@@ -1,33 +0,0 @@
-export * from './types.js';
-export * from './util.js';
-export * from './case.js';
-export * from './JJET.js';
-export * from './JJN.js';
-import './JJN-wrap.js';
-export * from './JJT.js';
-export * from './JJE.js';
-export * from './JJHE.js';
-export * from './JJSE.js';
-export * from './JJD.js';
-export * from './JJDF.js';
-export * from './JJSR.js';
-export * from './helpers.js';
-export * from './components.js';
-import { JJD } from './JJD.js';
-/**
- * A wrapped document for convenience.
- * It can be used instead of document
- *
- * @example
- * ```ts
- * const el = doc.byId('my-element') // A JJHE instance
- * const body = doc.body             // A JJHE instance
- * doc.append(JJHE.fromTag('script').setAttr('src', 'my-code.js'))
- * doc.head.append(JJHE.fromTag('link').setAttr({
- *   rel: 'stylesheet',
- *   href: 'code.css'
- * }))
- * ```
- */
-declare const doc: JJD<Document>;
-export default doc;

package/lib/index.js

@@ -1,35 +0,0 @@
-export * from './types.js';
-export * from './util.js';
-export * from './case.js';
-export * from './JJET.js';
-export * from './JJN.js';
-// Monkey patch the wrap() method which requires all the other JJ classes
-import './JJN-wrap.js';
-export * from './JJT.js';
-export * from './JJE.js';
-export * from './JJHE.js';
-export * from './JJSE.js';
-export * from './JJD.js';
-export * from './JJDF.js';
-export * from './JJSR.js';
-export * from './helpers.js';
-export * from './components.js';
-import { JJD } from './JJD.js';
-/**
- * A wrapped document for convenience.
- * It can be used instead of document
- *
- * @example
- * ```ts
- * const el = doc.byId('my-element') // A JJHE instance
- * const body = doc.body             // A JJHE instance
- * doc.append(JJHE.fromTag('script').setAttr('src', 'my-code.js'))
- * doc.head.append(JJHE.fromTag('link').setAttr({
- *   rel: 'stylesheet',
- *   href: 'code.css'
- * }))
- * ```
- */
-const doc = JJD.from(document);
-export default doc;
-//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,WAAW,CAAA;AACzB,cAAc,WAAW,CAAA;AACzB,cAAc,WAAW,CAAA;AACzB,cAAc,UAAU,CAAA;AACxB,yEAAyE;AACzE,OAAO,eAAe,CAAA;AACtB,cAAc,UAAU,CAAA;AACxB,cAAc,UAAU,CAAA;AACxB,cAAc,WAAW,CAAA;AACzB,cAAc,WAAW,CAAA;AACzB,cAAc,UAAU,CAAA;AACxB,cAAc,WAAW,CAAA;AACzB,cAAc,WAAW,CAAA;AACzB,cAAc,cAAc,CAAA;AAC5B,cAAc,iBAAiB,CAAA;AAE/B,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAA;AAE9B;;;;;;;;;;;;;;GAcG;AACH,MAAM,GAAG,GAAG,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;AAC9B,eAAe,GAAG,CAAA"}

package/lib/internal.d.ts

@@ -1,30 +0,0 @@
-/**
- * Internal utilities for the JJ library.
- * These are not part of the public API.
- */
-/**
- * Creates a gzip-friendly error message by concatenating strings.
- * This avoids repeating common error message patterns that compress well.
- *
- * @remarks
- * Uses backtick strings to take advantage of gzip compression across the codebase.
- * Common patterns like `Expected 'x' to be ...` compress very efficiently.
- *
- * @internal
- * @param varName - The name of the variable
- * @param expected - Description of expected type
- * @param received - The actual value received
- * @returns Error message string
- */
-export declare function errMsg(varName: string, expected: string, received: unknown): string;
-/**
- * Creates a TypeError with a standardized error message.
- * Convenience wrapper around errMsg for type errors.
- *
- * @internal
- * @param varName - The name of the variable
- * @param expected - Description of expected type
- * @param received - The actual value received
- * @returns A TypeError ready to be thrown
- */
-export declare function typeErr(varName: string, expected: string, received: unknown): TypeError;

package/lib/internal.js

@@ -1,35 +0,0 @@
-/**
- * Internal utilities for the JJ library.
- * These are not part of the public API.
- */
-/**
- * Creates a gzip-friendly error message by concatenating strings.
- * This avoids repeating common error message patterns that compress well.
- *
- * @remarks
- * Uses backtick strings to take advantage of gzip compression across the codebase.
- * Common patterns like `Expected 'x' to be ...` compress very efficiently.
- *
- * @internal
- * @param varName - The name of the variable
- * @param expected - Description of expected type
- * @param received - The actual value received
- * @returns Error message string
- */
-export function errMsg(varName, expected, received) {
-    return `Expected '${varName}' to be ${expected}. Got ${received} (${typeof received})`;
-}
-/**
- * Creates a TypeError with a standardized error message.
- * Convenience wrapper around errMsg for type errors.
- *
- * @internal
- * @param varName - The name of the variable
- * @param expected - Description of expected type
- * @param received - The actual value received
- * @returns A TypeError ready to be thrown
- */
-export function typeErr(varName, expected, received) {
-    return new TypeError(errMsg(varName, expected, received));
-}
-//# sourceMappingURL=internal.js.map

package/lib/internal.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"internal.js","sourceRoot":"","sources":["../src/internal.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,MAAM,CAAC,OAAe,EAAE,QAAgB,EAAE,QAAiB;IACvE,OAAO,aAAa,OAAO,WAAW,QAAQ,SAAS,QAAQ,KAAK,OAAO,QAAQ,GAAG,CAAA;AAC1F,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,OAAO,CAAC,OAAe,EAAE,QAAgB,EAAE,QAAiB;IACxE,OAAO,IAAI,SAAS,CAAC,MAAM,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAA;AAC7D,CAAC"}

package/lib/types.d.ts

@@ -1,65 +0,0 @@
-import type { JJD } from './JJD.js';
-import type { JJDF } from './JJDF.js';
-import type { JJE } from './JJE.js';
-import type { JJHE } from './JJHE.js';
-import type { JJN } from './JJN.js';
-import type { JJSE } from './JJSE.js';
-import type { JJSR } from './JJSR.js';
-import type { JJT } from './JJT.js';
-/**
- * Represents any value that can be wrapped by the library.
- * Can be a native Node, a string (which becomes a Text node), or an existing JJ wrapper.
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Node | Node}
- */
-export type Wrappable = string | Node | JJN;
-/**
- * Union type of all possible JJ wrapper classes.
- */
-export type Wrapped = JJN | JJT | JJE | JJHE | JJSE | JJD | JJDF | JJSR;
-/**
- * Union type of all native DOM nodes that correspond to JJ wrappers.
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Node | Node}
- */
-export type Unwrapped = Node | Text | Element | HTMLElement | SVGElement | Document | DocumentFragment | ShadowRoot;
-/**
- * Configuration for the component's template.
- * Can be an HTML string, a JJHE instance, a raw HTMLElement, or a
- * Promise / factory that yields one of those.
- *
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Element/innerHTML | Element.innerHTML}
- * @example
- * ```ts
- * const t1: tmplConf = '<div>Hello</div>'
- * const t2: tmplConf = fetchHtml('./template.html') // Lazy loading
- * const t3: tmplConf = () => fetchHtml('./template.html') // Lazy loading
- * const t4: tmplConf = new JJHE(document.createElement('div')) // JJHE instance
- * const t5: tmplConf = document.createElement('div') // Raw HTMLElement
- * const t6: tmplConf = await fetchHtml('./template.html') // Eager loading
- * ```
- */
-export type JJTemplateConfig = string | JJHE | HTMLElement | Promise<string | JJHE | HTMLElement> | (() => string | JJHE | HTMLElement | Promise<string | JJHE | HTMLElement>);
-/**
- * Configuration for the component's styles.
- * Can be a CSS string, a CSSStyleSheet, or a Promise / factory that yields one of those.
- *
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleSheet | CSSStyleSheet}
- * @example
- * ```ts
- * const s1: JJStyleConfig = 'p { color: red; }' // simple string
- * const s2: JJStyleConfig = cssToSheet('p { color: red; }') // Parse string to CSSStyleSheet
- * const s3: JJStyleConfig = await fetchCss('./style.css') // Eager loading
- * const s4: JJStyleConfig = fetchCss('./style.css') // Lazy loading
- * const s5: JJStyleConfig = () => fetchCss('./style.css') // Lazy loading
- * ```
- */
-export type JJStyleConfig = string | CSSStyleSheet | Promise<string | CSSStyleSheet> | (() => string | CSSStyleSheet | Promise<string | CSSStyleSheet>);
-/**
- * Configuration for initializing a shadowRoot
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/ShadowRoot/adoptedStyleSheets | ShadowRoot.adoptedStyleSheets}
- */
-export interface ShadowConfig {
-    /** Optional HTML content to set in the shadow root */
-    template?: string;
-    /** Optional CSSStyleSheets to adopt in the shadow root */
-    styles?: CSSStyleSheet[];
-}

package/lib/types.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=types.js.map

package/lib/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/lib/util.d.ts

@@ -1,68 +0,0 @@
-/**
- * Returns the file extension
- *
- * @remarks
- * This convenience function is primarily used to guess the 'as' attribute of
- * a link preload/prefetch behind the scene.
- *
- * @example
- * ```ts
- * fileExt('file.txt') // => 'txt'
- * fileExt('https://www.alexewerlof.com/path/to/file.js') // => 'js'
- * ```
- *
- * @param path - absolute, relative, or URL path to a file
- * @returns the extension name in lowercase and without any dot prefix
- * @throws {TypeError} If path is not a string.
- */
-export declare function fileExt(path: string): string;
-/**
- * Returns a promise that resolves before the next repaint.
- *
- * @remarks
- * Used to give the UI a moment to update.
- *
- * @example
- * ```ts
- * await nextAnimationFrame()
- * ```
- *
- * @returns A promise that resolves with the timestamp.
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/window/requestAnimationFrame | requestAnimationFrame}
- */
-export declare function nextAnimationFrame(): Promise<number>;
-/**
- * Returns a promise that resolves after the specified delay.
- *
- * @remarks
- * Uses `setTimeout` to delay execution. When used with 0ms, it defers
- * execution to the next macro-task, allowing the event loop to cycle.
- *
- * @example
- * ```ts
- * await sleep(100)
- * await sleep() // equivalent to setTimeout(..., 0)
- * ```
- *
- * @param ms - The delay in milliseconds. Defaults to 0.
- * @returns A promise that resolves after the delay.
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/setTimeout | setTimeout}
- */
-export declare function sleep(ms?: number): Promise<void>;
-/**
- * Converts a CSS string to a CSSStyleSheet.
- *
- * @remarks
- * Suitable for attaching to ShadowRoot via `adoptedStyleSheets`.
- *
- * @example
- * ```ts
- * const sheet = await cssToStyle('p { color: red; }')
- * shadowRoot.adoptedStyleSheets = [sheet]
- * ```
- *
- * @param css - The CSS string.
- * @returns A promise resolving to the created CSSStyleSheet.
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleSheet/replace | CSSStyleSheet.replace}
- */
-export declare function cssToStyle(css: string): Promise<CSSStyleSheet>;

package/lib/util.js

@@ -1,90 +0,0 @@
-import { isStr } from 'jty';
-/**
- * Returns the file extension
- *
- * @remarks
- * This convenience function is primarily used to guess the 'as' attribute of
- * a link preload/prefetch behind the scene.
- *
- * @example
- * ```ts
- * fileExt('file.txt') // => 'txt'
- * fileExt('https://www.alexewerlof.com/path/to/file.js') // => 'js'
- * ```
- *
- * @param path - absolute, relative, or URL path to a file
- * @returns the extension name in lowercase and without any dot prefix
- * @throws {TypeError} If path is not a string.
- */
-export function fileExt(path) {
-    if (!isStr(path)) {
-        throw new TypeError(`Expected a string file path. Got ${path} (${typeof path})`);
-    }
-    const lastDotIndex = path.lastIndexOf('.');
-    if (lastDotIndex === -1) {
-        return '';
-    }
-    const ext = path.slice(lastDotIndex + 1);
-    if (ext.indexOf('/') !== -1) {
-        return '';
-    }
-    return ext.toLowerCase().trim();
-}
-/**
- * Returns a promise that resolves before the next repaint.
- *
- * @remarks
- * Used to give the UI a moment to update.
- *
- * @example
- * ```ts
- * await nextAnimationFrame()
- * ```
- *
- * @returns A promise that resolves with the timestamp.
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/window/requestAnimationFrame | requestAnimationFrame}
- */
-export function nextAnimationFrame() {
-    return new Promise((resolve) => requestAnimationFrame(resolve));
-}
-/**
- * Returns a promise that resolves after the specified delay.
- *
- * @remarks
- * Uses `setTimeout` to delay execution. When used with 0ms, it defers
- * execution to the next macro-task, allowing the event loop to cycle.
- *
- * @example
- * ```ts
- * await sleep(100)
- * await sleep() // equivalent to setTimeout(..., 0)
- * ```
- *
- * @param ms - The delay in milliseconds. Defaults to 0.
- * @returns A promise that resolves after the delay.
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/setTimeout | setTimeout}
- */
-export function sleep(ms = 0) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-/**
- * Converts a CSS string to a CSSStyleSheet.
- *
- * @remarks
- * Suitable for attaching to ShadowRoot via `adoptedStyleSheets`.
- *
- * @example
- * ```ts
- * const sheet = await cssToStyle('p { color: red; }')
- * shadowRoot.adoptedStyleSheets = [sheet]
- * ```
- *
- * @param css - The CSS string.
- * @returns A promise resolving to the created CSSStyleSheet.
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleSheet/replace | CSSStyleSheet.replace}
- */
-export async function cssToStyle(css) {
-    const sheet = new CSSStyleSheet();
-    return await sheet.replace(css);
-}
-//# sourceMappingURL=util.js.map

package/lib/util.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"util.js","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,KAAK,CAAA;AAE3B;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,OAAO,CAAC,IAAY;IAChC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;QACf,MAAM,IAAI,SAAS,CAAC,oCAAoC,IAAI,KAAK,OAAO,IAAI,GAAG,CAAC,CAAA;IACpF,CAAC;IACD,MAAM,YAAY,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAA;IAC1C,IAAI,YAAY,KAAK,CAAC,CAAC,EAAE,CAAC;QACtB,OAAO,EAAE,CAAA;IACb,CAAC;IACD,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,GAAG,CAAC,CAAC,CAAA;IACxC,IAAI,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC;QAC1B,OAAO,EAAE,CAAA;IACb,CAAC;IACD,OAAO,GAAG,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,CAAA;AACnC,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,kBAAkB;IAC9B,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,qBAAqB,CAAC,OAAO,CAAC,CAAC,CAAA;AACnE,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,KAAK,CAAC,KAAa,CAAC;IAChC,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAA;AAC5D,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,KAAK,UAAU,UAAU,CAAC,GAAW;IACxC,MAAM,KAAK,GAAG,IAAI,aAAa,EAAE,CAAA;IACjC,OAAO,MAAM,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;AACnC,CAAC"}

package/llms.txt

@@ -1,214 +0,0 @@
-# JJ: The DOM Library for AI-Assisted Development
-
-## What is JJ?
-
-JJ is a minimal, imperative DOM manipulation library designed for modern web development. It provides small wrapper classes around DOM interfaces with a fluent API for chaining operations. JJ is zero-dependency, TypeScript-first, and optimized for AI-assisted code generation.
-
-## Core Principles
-
-1. **Imperative by Design**: Direct DOM manipulation without virtual DOM overhead.
-2. **Type-Safe**: Full TypeScript support with precise generic types for one-shot LLM correctness.
-3. **Chainable**: All public methods support fluent chaining.
-4. **Zero Build**: Works directly in browsers via ESM imports or bundled script tags.
-5. **Self-Correcting Errors**: Error messages suggest the correct approach.
-
-## Main Classes
-
-- **JJD**: Wraps `Document`. Entry point for querying and creating elements.
-- **JJN**: Wraps `Node`. Base for other wrappers.
-- **JJE**: Wraps `Element`. Generic element wrapper.
-- **JJHE**: Wraps `HTMLElement`. Extends JJE with HTML-specific methods.
-- **JJT**: Wraps `Text`. Text node operations.
-- **JJSR**: Wraps `ShadowRoot`. Shadow DOM operations.
-- **JJDF**: Wraps `DocumentFragment`. Fragment operations.
-- **JJSE**: Wraps `StyleSheet`. Style operations.
-
-## Quick Start
-
-```typescript
-import { JJD } from 'jj';
-
-// Query an element
-const btn = JJD.from(document).query('button#submit');
-
-// Set attributes and classes
-btn.attr('disabled', 'true').addClass('highlight');
-
-// Listen to events
-btn.on('click', () => console.log('Clicked!'));
-
-// Create and append elements
-const div = JJD.from(document).create('div').setText('Hello, World!');
-btn.parentNode?.appendChild(div.ref);
-```
-
-## Patterns and Examples
-
-### Creating Elements
-
-```typescript
-const el = JJD.from(document).create('div').addClass('container');
-```
-
-### Querying Elements
-
-```typescript
-const btn = JJD.from(document).query('.btn');
-const buttons = JJD.from(document).queryAll('button');
-```
-
-### Manipulating Classes
-
-```typescript
-el.addClass('active').removeClass('disabled').toggleClass('visible');
-```
-
-### Setting Attributes and Properties
-
-```typescript
-el.attr('data-id', '42').prop('disabled', false);
-```
-
-### Listening to Events
-
-```typescript
-el.on('click', (e) => { /* handle click */ });
-el.off('click');
-```
-
-### Styling
-
-```typescript
-el.style('background-color', 'blue').style('padding', '10px');
-```
-
-### Accessing the Underlying Node
-
-Every JJ wrapper exposes `.ref` to access the underlying DOM node:
-
-```typescript
-const nativeElement = el.ref; // HTMLElement
-```
-
-## For LLMs: Translation Patterns
-
-### React to JJ
-
-**React**: State-driven component re-renders on state change.
-```tsx
-const [count, setCount] = useState(0);
-return <button onClick={() => setCount(count + 1)}>{count}</button>;
-```
-
-**JJ**: Direct DOM mutation and event binding.
-```typescript
-let count = 0;
-const btn = JJD.from(document).create('button').setText('0');
-btn.on('click', () => {
-  count++;
-  btn.setText(String(count));
-});
-```
-
-### jQuery to JJ
-
-**jQuery**: Chainable DOM manipulation with `$()` selector.
-```javascript
-$('.box').addClass('active').css('color', 'red');
-```
-
-**JJ**: Similar chainable API with type safety.
-```typescript
-JJD.from(document).query('.box').addClass('active').style('color', 'red');
-```
-
-### Vue to JJ
-
-**Vue**: Template-driven, two-way binding.
-```vue
-<div>
-  <input v-model="message" />
-  <p>{{ message }}</p>
-</div>
-```
-
-**JJ**: Imperative setup with manual event binding.
-```typescript
-const input = JJD.from(document).create('input');
-const p = JJD.from(document).create('p');
-input.on('input', (e) => {
-  p.setText((e.target as HTMLInputElement).value);
-});
-```
-
-### Svelte to JJ
-
-**Svelte**: Reactive variables and automatic re-renders.
-```svelte
-<script>
-  let count = 0;
-</script>
-<button on:click={() => count++}>{count}</button>
-```
-
-**JJ**: Manual DOM updates on events.
-```typescript
-let count = 0;
-const btn = JJD.from(document).create('button').setText('0');
-btn.on('click', () => {
-  count++;
-  btn.setText(String(count));
-});
-```
-
-## TypeScript Type Safety
-
-JJ leverages TypeScript generics to ensure type safety. For example:
-
-```typescript
-const input = JJD.from(document).fromTag('input');
-// input is JJHE<HTMLInputElement>, so input.ref.value is known to exist
-
-const div = JJD.from(document).fromTag('div');
-// div is JJHE<HTMLDivElement>, so input.ref.value would be a type error
-```
-
-This prevents LLM hallucinations about non-existent properties.
-
-## Common Gotchas
-
-1. **Accessing the Native Node**: Always use `.ref` to access the underlying DOM node for operations not exposed by JJ.
-2. **Event Listeners**: Use `.on()` and `.off()` for proper cleanup.
-3. **Fragments**: Use JJDF for batch operations before appending.
-4. **Error Messages**: Read them carefully—they suggest the correct approach.
-
-## Testing
-
-JJ uses Node's built-in test runner with `tsx`:
-
-```bash
-npm test
-```
-
-Tests are colocated with source files as `*.test.ts`.
-
-## Building
-
-```bash
-npm run build
-```
-
-This runs TypeScript compilation, creates an ESM bundle and minified variant, and generates documentation.
-
-## Resources
-
-- **GitHub**: https://github.com/alexewerlof/jj
-- **Documentation**: https://jj.rocks/doc/
-- **Examples**: https://jj.rocks/examples/
-
-## For Best Results with LLMs
-
-1. When asking an LLM to help with JJ code, provide a snippet of the desired DOM structure.
-2. Reference the translation patterns above when converting from React, Vue, Svelte, or jQuery.
-3. Ask the LLM to use `.ref` when accessing native properties not exposed by JJ.
-4. Expect type errors to be self-documenting—they guide toward the correct API.