jsx-object 0.0.0-stage → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Guilherme Chaguri
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,307 @@
-# Temporary Holding Version
+# jsx-object
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![npm version](https://img.shields.io/npm/v/jsx-object)](https://www.npmjs.com/package/jsx-object)
+[![bundle size](https://img.shields.io/bundlephobia/minzip/jsx-object)](https://bundlephobia.com/package/jsx-object)
+[![license](https://img.shields.io/npm/l/jsx-object)](./LICENSE)
+
+A tiny, dependency-free JSX runtime that turns JSX into plain JavaScript objects.
+
+```tsx
+// Write React-like components that return an object
+const Post = (props: PostProps) => {
+  return { type: 'post', title: props.title };
+}
+
+// Use JSX to build the object
+console.log(<Post title="Hello World!" />)
+// { type: 'post', title: 'Hello World!' }
+```
+
+There is no virtual DOM, no rendering step and no reconciliation: a JSX expression evaluates directly to whatever your components return.
+
+- [Why?](#why)
+- [Getting Started](#getting-started)
+- [Examples](#examples)
+- [TypeScript](#typescript)
+- [Behavior Notes](#behavior-notes)
+- [Compatibility](#compatibility)
+- [Contributing](#contributing)
+
+## Why?
+
+JSX is a great syntax for describing trees, and trees aren't only HTML. Use jsx-object when you want to build structured data with composable components, for example:
+
+- **Server-driven UI**: build the JSON payloads your mobile or web clients render.
+- **CMS and JSON templates**: assemble documents from reusable, typed pieces.
+- **Configuration DSLs**: describe pipelines, forms or workflows declaratively.
+
+Compared to similar tools:
+
+- **React** renders elements into a UI. jsx-object has no rendering step: the result *is* the data.
+- **[Kita Html](https://html.kitajs.org/)** turns JSX into HTML strings. jsx-object turns JSX into objects.
+
+## Getting Started
+
+First, install the library:
+
+```shell
+npm install jsx-object
+```
+
+Then add the following JSX configuration to your `tsconfig.json`:
+
+```json
+{
+  "compilerOptions": {
+    "jsx": "react-jsx",
+    "jsxImportSource": "jsx-object"
+  }
+}
+```
+
+### Other build tools
+
+Tools that read `tsconfig.json`, such as Vite, esbuild, tsx and Bun, pick this up automatically. Otherwise, configure the automatic JSX runtime with `jsx-object` as the import source:
+
+<details>
+<summary>esbuild</summary>
+
+```shell
+esbuild app.tsx --jsx=automatic --jsx-import-source=jsx-object
+```
+
+</details>
+
+<details>
+<summary>Babel</summary>
+
+```json
+{
+  "plugins": [
+    ["@babel/plugin-transform-react-jsx", { "runtime": "automatic", "importSource": "jsx-object" }]
+  ]
+}
+```
+
+</details>
+
+<details>
+<summary>SWC</summary>
+
+```json
+{
+  "jsc": {
+    "transform": {
+      "react": { "runtime": "automatic", "importSource": "jsx-object" }
+    }
+  }
+}
+```
+
+</details>
+
+To use jsx-object in only some files, add this comment to the top of each file instead:
+
+```tsx
+/** @jsxImportSource jsx-object */
+```
+
+> [!NOTE]
+> jsx-object declares a global `JSX` namespace, so it can't share a TypeScript project with other libraries that also declare one, such as `@types/react` 18.
+
+## Examples
+
+### Components
+
+Compose any number of components together.
+
+```tsx
+const Paragraph = (props: ParagraphProps) => {
+  return { type: 'paragraph', content: props.children, variant: props.variant };
+}
+
+const Card = (props: CardProps) => {
+  return { type: 'card', paragraphs: props.children };
+}
+
+const Post = (props: PostProps) => {
+  return (
+    <Card>
+      <Paragraph variant="h1">{props.title}</Paragraph>
+      <Paragraph>{props.description}</Paragraph>
+      <Paragraph>Share</Paragraph>
+    </Card>
+  );
+}
+
+console.log(<Post title="Hello World!" description="Lorem Ipsum" />);
+// {
+//    type: 'card',
+//    paragraphs: [
+//      { type: 'paragraph', content: 'Hello World!', variant: 'h1' },
+//      { type: 'paragraph', content: 'Lorem Ipsum', variant: undefined },
+//      { type: 'paragraph', content: 'Share', variant: undefined },
+//    ]
+// }
+```
+
+### Async Components
+
+Components can be async. If any component in the tree is async, the whole result becomes a Promise.
+
+```tsx
+const Product = async (props: { id: number }) => {
+  const product = await fetchProduct(props.id);
+
+  return <Paragraph>{product.name}</Paragraph>;
+};
+
+// The await is necessary here
+console.log(await <Product id={32} />)
+```
+
+Async siblings are resolved in parallel, and the result keeps their original order.
+
+Mapped lists of async components are awaited too, wherever they appear among the children:
+
+```tsx
+<List>
+  <Paragraph>Products</Paragraph>
+  {ids.map((id) => <Product id={id} />)}
+</List>
+```
+
+### Children
+
+Children can be either a single object or an array of objects.
+
+```tsx
+const data = (
+  <Paragraph>Hello</Paragraph>
+)
+
+console.log(data);
+// { type: 'paragraph', content: 'Hello', variant: undefined }
+```
+
+Use a fragment (`<>...</>`) to return several objects as an array:
+
+```tsx
+const data = (
+  <>
+    <Paragraph>Hello</Paragraph>
+    <Paragraph>World</Paragraph>
+  </>
+)
+
+console.log(data);
+// [
+//   { type: 'paragraph', content: 'Hello', variant: undefined },
+//   { type: 'paragraph', content: 'World', variant: undefined },
+// ]
+```
+
+## TypeScript
+
+jsx-object exports a few helper types:
+
+```tsx
+import type { Children, Component, PropsWithChildren } from 'jsx-object';
+
+// Children: anything that can be passed as children, including promises and arrays
+interface CardProps {
+  title: string;
+  children?: Children;
+}
+
+// PropsWithChildren<T>: adds an optional `children` prop to T
+type SectionProps = PropsWithChildren<{ title: string }>;
+
+// Component<T>: a component function that receives T plus children
+const Section: Component<{ title: string }> = (props) => {
+  return { type: 'section', title: props.title, content: props.children };
+};
+```
+
+### Typing results
+
+TypeScript can't infer what a component returns from a JSX expression: every JSX expression has the type `JSX.Element`, which is `JSX.ComponentObject | Promise<JSX.ComponentObject>`. `JSX.ComponentObject` is a loose object type whose properties are all `any`, so reading properties from a result compiles without type checking, typos included. Cast the result to the type you expect:
+
+```tsx
+interface PostObject {
+  type: 'post';
+  title: string;
+}
+
+const post = <Post title="Hello World!" /> as PostObject;
+
+// For async trees, await first
+const product = (await <Product id={32} />) as ProductObject;
+```
+
+### Extending the JSX types
+
+The `JSX` namespace is global, so `JSX.Element` and `JSX.ComponentObject` are available without an import. Extend it with a `declare global` block from any module file in your project:
+
+```tsx
+export {};
+
+declare global {
+  namespace JSX {
+    // Declare custom tags, with type-checked props
+    interface IntrinsicElements {
+      box: { color?: string };
+    }
+
+    // Accept an extra prop on every component
+    interface IntrinsicAttributes {
+      testId?: string;
+    }
+
+    // Require every component to return an object with a `type`
+    interface ComponentObject {
+      type: string;
+    }
+  }
+}
+```
+
+Members added to `ComponentObject` apply to every component, whether it's sync or async, or returns another component's JSX. Use optional members to allow a property without requiring it. If a member uses literal types, such as `type: 'text' | 'stack'`, components must return those values `as const`, since TypeScript otherwise widens them to `string`.
+
+You can add members and new types, but you can't redefine existing ones: `JSX.Element` is fixed, `ComponentObject` keeps its `any` index signature, and existing interface members, such as `key`, keep their types.
+
+## Behavior Notes
+
+### Errors
+
+If an async component throws or rejects, the whole tree rejects with that error, and parent components are never called.
+
+### No built-in tags
+
+There are no intrinsic elements such as `<div>`. A lowercase tag simply returns its children, and TypeScript rejects it unless you declare it yourself, as shown in [Extending the JSX types](#extending-the-jsx-types).
+
+### `key` is reserved
+
+The JSX transform strips the `key` prop before it reaches your components. If you need a similar prop, use another name such as `id`.
+
+## Compatibility
+
+- Ships both ESM and CommonJS builds, with type declarations for each.
+- No runtime dependencies. Runs in any ES2018+ environment.
+- Requires TypeScript 4.1 or later, for `jsxImportSource` support.
+
+## Contributing
+
+```shell
+npm install
+npm test        # run the unit tests
+npm run build   # build the package into dist/
+```
+
+## Credits
+
+This library was based on the concept of [Kita Html](https://html.kitajs.org/).
+
+## License
+
+[MIT](./LICENSE)

package/dist/index.cjs

@@ -0,0 +1,6 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+// src/index.ts
+function Fragment(props) {
+	return props.children ?? [];
+}
+exports.Fragment = Fragment;

package/dist/index.d.cts

@@ -0,0 +1,42 @@
+declare global {
+  namespace JSX {
+    interface ComponentObject {
+      [key: string]: any;
+    }
+    /**
+     * A `JSX.Element` is always the component object, unless one of their children is a Promise,
+     * which makes it also be a Promise
+     */
+    type Element<T = ComponentObject> = T | Promise<T>;
+    interface IntrinsicAttributes {
+      /**
+       * In `react-jsx`, the `'key'` attribute serves as a reserved attribute name.
+       * Consequently, the `'key'` attribute is not included in the properties parameter
+       * of any component or element.
+       *
+       * **If you intend to utilize a similar property, please opt for an alternate
+       * name.**
+       *
+       * @see https://github.com/reactjs/rfcs/pull/107
+       */
+      key?: undefined | never;
+    }
+    interface ElementChildrenAttribute {
+      children?: undefined | Children;
+    }
+    /**
+     * No intrinsic elements are defined in this JSX namespace.
+     *
+     * This is intentional, as the JSX namespace is designed to be extended by other libraries or
+     * frameworks that define their own intrinsic elements.
+     */
+    interface IntrinsicElements {}
+  }
+}
+export type Children = null | undefined | JSX.Element | Promise<Children> | Children[];
+export type PropsWithChildren<T = {}> = {
+  children?: Children;
+} & T;
+export type Component<T = {}> = (this: void, props: PropsWithChildren<T>) => JSX.Element;
+export declare function Fragment(props: PropsWithChildren): JSX.Element;
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":["_$__index_js0.Children"],"sources":["../src/jsx.ts","../src/index.ts"],"mappings":"A,QAAQ;YACI;cACE;OACP;;;;;;SAOE,QAAQ,IAAI,mBAAmB,IAAI,QAAQ;cAEtC;;;;;;;;;;;MAWR;;cAGQ;MACR,uBAjBsCA;;;;;;;;cA0B9B;;;YClCF,8BAGR,IAAI,UACJ,QAAQ,YACR;YAEQ,kBAAkB;EAAY,WAAW;IAAa;YAEtD,UAAU,WAAW,YAAY,OAAO,kBAAkB,OAAO,IAAI;wBAEjE,SACd,OAAO,oBACN,IAAI"}

package/dist/index.d.ts

@@ -0,0 +1,42 @@
+declare global {
+  namespace JSX {
+    interface ComponentObject {
+      [key: string]: any;
+    }
+    /**
+     * A `JSX.Element` is always the component object, unless one of their children is a Promise,
+     * which makes it also be a Promise
+     */
+    type Element<T = ComponentObject> = T | Promise<T>;
+    interface IntrinsicAttributes {
+      /**
+       * In `react-jsx`, the `'key'` attribute serves as a reserved attribute name.
+       * Consequently, the `'key'` attribute is not included in the properties parameter
+       * of any component or element.
+       *
+       * **If you intend to utilize a similar property, please opt for an alternate
+       * name.**
+       *
+       * @see https://github.com/reactjs/rfcs/pull/107
+       */
+      key?: undefined | never;
+    }
+    interface ElementChildrenAttribute {
+      children?: undefined | Children;
+    }
+    /**
+     * No intrinsic elements are defined in this JSX namespace.
+     *
+     * This is intentional, as the JSX namespace is designed to be extended by other libraries or
+     * frameworks that define their own intrinsic elements.
+     */
+    interface IntrinsicElements {}
+  }
+}
+export type Children = null | undefined | JSX.Element | Promise<Children> | Children[];
+export type PropsWithChildren<T = {}> = {
+  children?: Children;
+} & T;
+export type Component<T = {}> = (this: void, props: PropsWithChildren<T>) => JSX.Element;
+export declare function Fragment(props: PropsWithChildren): JSX.Element;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":["_$__index_js0.Children"],"sources":["../src/jsx.ts","../src/index.ts"],"mappings":"A,QAAQ;YACI;cACE;OACP;;;;;;SAOE,QAAQ,IAAI,mBAAmB,IAAI,QAAQ;cAEtC;;;;;;;;;;;MAWR;;cAGQ;MACR,uBAjBsCA;;;;;;;;cA0B9B;;;YClCF,8BAGR,IAAI,UACJ,QAAQ,YACR;YAEQ,kBAAkB;EAAY,WAAW;IAAa;YAEtD,UAAU,WAAW,YAAY,OAAO,kBAAkB,OAAO,IAAI;wBAEjE,SACd,OAAO,oBACN,IAAI"}

package/dist/index.js

@@ -0,0 +1,7 @@
+// src/index.ts
+function Fragment(props) {
+	return props.children ?? [];
+}
+export { Fragment };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["import './jsx.js';\n\nexport type Children =\n  | null\n  | undefined\n  | JSX.Element\n  | Promise<Children>\n  | Children[]\n\nexport type PropsWithChildren<T = {}> = { children?: Children } & T\n\nexport type Component<T = {}> = (this: void, props: PropsWithChildren<T>) => JSX.Element\n\nexport function Fragment(\n  props: PropsWithChildren\n): JSX.Element {\n  return props.children ?? [];\n}\n"],"mappings":";AAaA,SAAgB,SACd,OACa;CACb,OAAO,MAAM,YAAY,CAAC;AAC5B"}

package/dist/jsx-dev-runtime.cjs

@@ -0,0 +1,23 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_index = require("./index.cjs");
+const require_jsx_runtime = require("./jsx-runtime.cjs");
+// src/jsx-dev-runtime.ts
+/**
+* Generates an object from an attribute name of component and it's props.
+*
+* This function is meant to be used by the jsx runtime and should not be called directly.
+*
+* @param name The name of the element to create or another component function
+* @param attributes The props to apply to the component
+* @param key The element key, which is ignored
+* @param isStaticChildren Whether the children are a static array, as passed to {@linkcode jsxs}
+* @retuns The generated object or a promise that resolves to the generated object
+*/
+function jsxDEV(name, attributes, key, isStaticChildren) {
+	if (isStaticChildren && Array.isArray(attributes.children)) return require_jsx_runtime.jsxs(name, attributes);
+	return require_jsx_runtime.jsx(name, attributes);
+}
+exports.Fragment = require_index.Fragment;
+exports.jsx = require_jsx_runtime.jsx;
+exports.jsxDEV = jsxDEV;
+exports.jsxs = require_jsx_runtime.jsxs;

package/dist/jsx-dev-runtime.d.cts

@@ -0,0 +1,19 @@
+import { Children, Fragment } from "./index.cjs";
+import { jsx, jsxs } from "./jsx-runtime.cjs";
+/**
+ * Generates an object from an attribute name of component and it's props.
+ *
+ * This function is meant to be used by the jsx runtime and should not be called directly.
+ *
+ * @param name The name of the element to create or another component function
+ * @param attributes The props to apply to the component
+ * @param key The element key, which is ignored
+ * @param isStaticChildren Whether the children are a static array, as passed to {@linkcode jsxs}
+ * @retuns The generated object or a promise that resolves to the generated object
+ */
+export declare function jsxDEV(this: void, name: string | Function, attributes: {
+  children?: Children;
+  [k: string]: any;
+}, key?: unknown, isStaticChildren?: boolean): JSX.Element;
+export { Fragment, jsx, jsxs };
+//# sourceMappingURL=jsx-dev-runtime.d.cts.map

package/dist/jsx-dev-runtime.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsx-dev-runtime.d.cts","names":[],"sources":["../src/jsx-dev-runtime.ts"],"mappings":";;;;;;;;;;;;;wBAgBgB,OACd,YACA,eAAe,UACf;EAAc,WAAW;GAAW;GACpC,eACA,6BACC,IAAI"}

package/dist/jsx-dev-runtime.d.ts

@@ -0,0 +1,19 @@
+import { Children, Fragment } from "./index.js";
+import { jsx, jsxs } from "./jsx-runtime.js";
+/**
+ * Generates an object from an attribute name of component and it's props.
+ *
+ * This function is meant to be used by the jsx runtime and should not be called directly.
+ *
+ * @param name The name of the element to create or another component function
+ * @param attributes The props to apply to the component
+ * @param key The element key, which is ignored
+ * @param isStaticChildren Whether the children are a static array, as passed to {@linkcode jsxs}
+ * @retuns The generated object or a promise that resolves to the generated object
+ */
+export declare function jsxDEV(this: void, name: string | Function, attributes: {
+  children?: Children;
+  [k: string]: any;
+}, key?: unknown, isStaticChildren?: boolean): JSX.Element;
+export { Fragment, jsx, jsxs };
+//# sourceMappingURL=jsx-dev-runtime.d.ts.map

package/dist/jsx-dev-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsx-dev-runtime.d.ts","names":[],"sources":["../src/jsx-dev-runtime.ts"],"mappings":";;;;;;;;;;;;;wBAgBgB,OACd,YACA,eAAe,UACf;EAAc,WAAW;GAAW;GACpC,eACA,6BACC,IAAI"}

package/dist/jsx-dev-runtime.js

@@ -0,0 +1,21 @@
+import { Fragment } from "./index.js";
+import { jsx, jsxs } from "./jsx-runtime.js";
+// src/jsx-dev-runtime.ts
+/**
+* Generates an object from an attribute name of component and it's props.
+*
+* This function is meant to be used by the jsx runtime and should not be called directly.
+*
+* @param name The name of the element to create or another component function
+* @param attributes The props to apply to the component
+* @param key The element key, which is ignored
+* @param isStaticChildren Whether the children are a static array, as passed to {@linkcode jsxs}
+* @retuns The generated object or a promise that resolves to the generated object
+*/
+function jsxDEV(name, attributes, key, isStaticChildren) {
+	if (isStaticChildren && Array.isArray(attributes.children)) return jsxs(name, attributes);
+	return jsx(name, attributes);
+}
+export { Fragment, jsx, jsxDEV, jsxs };
+
+//# sourceMappingURL=jsx-dev-runtime.js.map

package/dist/jsx-dev-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsx-dev-runtime.js","names":[],"sources":["../src/jsx-dev-runtime.ts"],"sourcesContent":["import type { Children } from './index.js'\nimport { jsx, jsxs } from './jsx-runtime.js'\n\nexport { Fragment, jsx, jsxs } from './jsx-runtime.js'\n\n/**\n * Generates an object from an attribute name of component and it's props.\n *\n * This function is meant to be used by the jsx runtime and should not be called directly.\n *\n * @param name The name of the element to create or another component function\n * @param attributes The props to apply to the component\n * @param key The element key, which is ignored\n * @param isStaticChildren Whether the children are a static array, as passed to {@linkcode jsxs}\n * @retuns The generated object or a promise that resolves to the generated object\n */\nexport function jsxDEV(\n  this: void,\n  name: string | Function,\n  attributes: { children?: Children; [k: string]: any },\n  key?: unknown,\n  isStaticChildren?: boolean\n): JSX.Element {\n  if (isStaticChildren && Array.isArray(attributes.children)) {\n    return jsxs(name, attributes as { children: Children[]; [k: string]: any })\n  }\n\n  return jsx(name, attributes)\n}\n"],"mappings":";;;;;;;;;;;;;;AAgBA,SAAgB,OAEd,MACA,YACA,KACA,kBACa;CACb,IAAI,oBAAoB,MAAM,QAAQ,WAAW,QAAQ,GACvD,OAAO,KAAK,MAAM,UAAwD;CAG5E,OAAO,IAAI,MAAM,UAAU;AAC7B"}

package/dist/jsx-runtime.cjs

@@ -0,0 +1,39 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_index = require("./index.cjs");
+// src/jsx-runtime.ts
+const processResult = (name, props, children) => {
+	if (typeof name === "function") return name({
+		...props,
+		children
+	});
+	return children;
+};
+const isPromise = (value) => {
+	return value && typeof value === "object" && typeof value.then === "function";
+};
+/**
+* Checks whether the children are a promise or contain one, at any array depth.
+* Mapped children (e.g. `{items.map(...)}`) are nested arrays inside the children array.
+*/
+const hasPromise = (children) => {
+	return isPromise(children) || Array.isArray(children) && children.some(hasPromise);
+};
+/**
+* Resolves every promise in the children, keeping nested arrays in place.
+*/
+const resolveChildren = (children) => {
+	if (Array.isArray(children)) return Promise.all(children.map(resolveChildren));
+	return Promise.resolve(children);
+};
+function jsx(name, attributes) {
+	if (hasPromise(attributes.children)) return resolveChildren(attributes.children).then((children) => {
+		return processResult(name, attributes, children);
+	});
+	return processResult(name, attributes, attributes.children);
+}
+function jsxs(name, attributes) {
+	return jsx(name, attributes);
+}
+exports.Fragment = require_index.Fragment;
+exports.jsx = jsx;
+exports.jsxs = jsxs;

package/dist/jsx-runtime.d.cts

@@ -0,0 +1,11 @@
+import { Children, Fragment } from "./index.cjs";
+export declare function jsx(this: void, name: string | Function, attributes: {
+  children?: Children;
+  [k: string]: any;
+}): JSX.Element;
+export declare function jsxs(this: void, name: string | Function, attributes: {
+  children: Children[];
+  [k: string]: any;
+}): JSX.Element;
+export { Fragment };
+//# sourceMappingURL=jsx-runtime.d.cts.map

package/dist/jsx-runtime.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsx-runtime.d.cts","names":[],"sources":["../src/jsx-runtime.ts"],"mappings":";wBAiCgB,IACd,YACA,eAAe,UACf;EAAc,WAAW;GAAW;IACnC,IAAI;wBAUS,KACd,YACA,eAAe,UACf;EAAc,UAAU;GAAa;IACpC,IAAI"}

package/dist/jsx-runtime.d.ts

@@ -0,0 +1,11 @@
+import { Children, Fragment } from "./index.js";
+export declare function jsx(this: void, name: string | Function, attributes: {
+  children?: Children;
+  [k: string]: any;
+}): JSX.Element;
+export declare function jsxs(this: void, name: string | Function, attributes: {
+  children: Children[];
+  [k: string]: any;
+}): JSX.Element;
+export { Fragment };
+//# sourceMappingURL=jsx-runtime.d.ts.map

package/dist/jsx-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsx-runtime.d.ts","names":[],"sources":["../src/jsx-runtime.ts"],"mappings":";wBAiCgB,IACd,YACA,eAAe,UACf;EAAc,WAAW;GAAW;IACnC,IAAI;wBAUS,KACd,YACA,eAAe,UACf;EAAc,UAAU;GAAa;IACpC,IAAI"}

package/dist/jsx-runtime.js

@@ -0,0 +1,38 @@
+import { Fragment } from "./index.js";
+// src/jsx-runtime.ts
+const processResult = (name, props, children) => {
+	if (typeof name === "function") return name({
+		...props,
+		children
+	});
+	return children;
+};
+const isPromise = (value) => {
+	return value && typeof value === "object" && typeof value.then === "function";
+};
+/**
+* Checks whether the children are a promise or contain one, at any array depth.
+* Mapped children (e.g. `{items.map(...)}`) are nested arrays inside the children array.
+*/
+const hasPromise = (children) => {
+	return isPromise(children) || Array.isArray(children) && children.some(hasPromise);
+};
+/**
+* Resolves every promise in the children, keeping nested arrays in place.
+*/
+const resolveChildren = (children) => {
+	if (Array.isArray(children)) return Promise.all(children.map(resolveChildren));
+	return Promise.resolve(children);
+};
+function jsx(name, attributes) {
+	if (hasPromise(attributes.children)) return resolveChildren(attributes.children).then((children) => {
+		return processResult(name, attributes, children);
+	});
+	return processResult(name, attributes, attributes.children);
+}
+function jsxs(name, attributes) {
+	return jsx(name, attributes);
+}
+export { Fragment, jsx, jsxs };
+
+//# sourceMappingURL=jsx-runtime.js.map

package/dist/jsx-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsx-runtime.js","names":[],"sources":["../src/jsx-runtime.ts"],"sourcesContent":["import type { Children } from './index.js';\n\nconst processResult = (name: string | Function, props: object, children: Children) => {\n  if (typeof name === 'function') {\n    return name({ ...props, children });\n  }\n\n  return children;\n}\n\nconst isPromise = (value: any): value is Promise<any> => {\n  return value && typeof value === 'object' && typeof value.then === 'function';\n}\n\n/**\n * Checks whether the children are a promise or contain one, at any array depth.\n * Mapped children (e.g. `{items.map(...)}`) are nested arrays inside the children array.\n */\nconst hasPromise = (children: any): boolean => {\n  return isPromise(children) || (Array.isArray(children) && children.some(hasPromise));\n}\n\n/**\n * Resolves every promise in the children, keeping nested arrays in place.\n */\nconst resolveChildren = (children: any): Promise<any> => {\n  if (Array.isArray(children)) {\n    return Promise.all(children.map(resolveChildren));\n  }\n\n  return Promise.resolve(children);\n}\n\nexport function jsx(\n  this: void,\n  name: string | Function,\n  attributes: { children?: Children; [k: string]: any }\n): JSX.Element {\n  if (hasPromise(attributes.children)) {\n    return resolveChildren(attributes.children).then(children => {\n      return processResult(name, attributes, children);\n    });\n  }\n\n  return processResult(name, attributes, attributes.children);\n}\n\nexport function jsxs(\n  this: void,\n  name: string | Function,\n  attributes: { children: Children[]; [k: string]: any }\n): JSX.Element {\n  return jsx(name, attributes);\n}\n\nexport { Fragment } from './index.js'\n"],"mappings":";;AAEA,MAAM,iBAAiB,MAAyB,OAAe,aAAuB;CACpF,IAAI,OAAO,SAAS,YAClB,OAAO,KAAK;EAAE,GAAG;EAAO;CAAS,CAAC;CAGpC,OAAO;AACT;AAEA,MAAM,aAAa,UAAsC;CACvD,OAAO,SAAS,OAAO,UAAU,YAAY,OAAO,MAAM,SAAS;AACrE;;;;;AAMA,MAAM,cAAc,aAA2B;CAC7C,OAAO,UAAU,QAAQ,KAAM,MAAM,QAAQ,QAAQ,KAAK,SAAS,KAAK,UAAU;AACpF;;;;AAKA,MAAM,mBAAmB,aAAgC;CACvD,IAAI,MAAM,QAAQ,QAAQ,GACxB,OAAO,QAAQ,IAAI,SAAS,IAAI,eAAe,CAAC;CAGlD,OAAO,QAAQ,QAAQ,QAAQ;AACjC;AAEA,SAAgB,IAEd,MACA,YACa;CACb,IAAI,WAAW,WAAW,QAAQ,GAChC,OAAO,gBAAgB,WAAW,QAAQ,CAAC,CAAC,MAAK,aAAY;EAC3D,OAAO,cAAc,MAAM,YAAY,QAAQ;CACjD,CAAC;CAGH,OAAO,cAAc,MAAM,YAAY,WAAW,QAAQ;AAC5D;AAEA,SAAgB,KAEd,MACA,YACa;CACb,OAAO,IAAI,MAAM,UAAU;AAC7B"}

package/package.json

@@ -1,6 +1,58 @@
 {
   "name": "jsx-object",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "type": "module",
+  "sideEffects": false,
+  "description": "Tiny, dependency-free JSX runtime that turns JSX into plain JavaScript objects, with async components. Great for server-driven UI and JSON templating.",
+  "keywords": [
+    "jsx",
+    "tsx",
+    "jsx-runtime",
+    "json",
+    "object",
+    "template",
+    "templating",
+    "server-driven-ui",
+    "sdui",
+    "async",
+    "components",
+    "typescript"
+  ],
+  "author": "Guichaguri",
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.cts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./jsx-dev-runtime": {
+      "import": "./dist/jsx-dev-runtime.js",
+      "require": "./dist/jsx-dev-runtime.cjs"
+    },
+    "./jsx-runtime": {
+      "import": "./dist/jsx-runtime.js",
+      "require": "./dist/jsx-runtime.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "prepublishOnly": "npm run build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "coverage": "vitest run --coverage --coverage.include=src/**"
+  },
+  "devDependencies": {
+    "@vitest/coverage-v8": "^5.1.0",
+    "publint": "^0.3.25",
+    "tsdown": "^0.23.5",
+    "typescript": "^7.0.2",
+    "vitest": "^5.1.0"
+  }
+}