@solidjs/html 2.0.0-rc.2 → 2.0.0-rc.4

package/types/tokenize.d.ts

@@ -0,0 +1,43 @@
+export declare const OPEN_TAG_TOKEN = 0;
+export declare const CLOSE_TAG_TOKEN = 1;
+export declare const SLASH_TOKEN = 2;
+export declare const IDENTIFIER_TOKEN = 3;
+export declare const EQUALS_TOKEN = 4;
+export declare const STRING_TOKEN = 5;
+export declare const TEXT_TOKEN = 6;
+export declare const EXPRESSION_TOKEN = 7;
+export declare const SPREAD_TOKEN = 8;
+export interface OpenTagToken {
+    type: typeof OPEN_TAG_TOKEN;
+}
+export interface CloseTagToken {
+    type: typeof CLOSE_TAG_TOKEN;
+}
+export interface SlashToken {
+    type: typeof SLASH_TOKEN;
+}
+export interface IdentifierToken {
+    type: typeof IDENTIFIER_TOKEN;
+    value: string;
+}
+export interface EqualsToken {
+    type: typeof EQUALS_TOKEN;
+}
+export interface StringToken {
+    type: typeof STRING_TOKEN;
+    value: string;
+    quote: "'" | '"';
+}
+export interface TextToken {
+    type: typeof TEXT_TOKEN;
+    value: string;
+}
+export interface SpreadToken {
+    type: typeof SPREAD_TOKEN;
+}
+export interface ExpressionToken {
+    type: typeof EXPRESSION_TOKEN;
+    value: number;
+}
+export type Token = OpenTagToken | CloseTagToken | SlashToken | IdentifierToken | EqualsToken | StringToken | TextToken | ExpressionToken | SpreadToken;
+export declare const tokenize: (strings: TemplateStringsArray | string[], rawTextElements: Set<string>) => Token[];

package/types/types.d.ts

@@ -0,0 +1,51 @@
+import type { JSX } from "@solidjs/web";
+export type FunctionComponent = (...args: any[]) => any;
+/**
+ * Component registry type
+ * @example
+ * ```tsx
+ * const components: ComponentRegistry = {
+ *   MyComponent: (props) => <div>Hello {props.name}</div>
+ * }
+ * ```
+ */
+export type ComponentRegistry = Record<string, FunctionComponent>;
+/**
+ * Tagged JSX instance type
+ * @template T Component registry
+ */
+export type TaggedJSXInstance<T extends ComponentRegistry> = {
+    /**
+     * Tagged JSX template function
+     * @example
+     * ```tsx
+     * const myTemplate = html`<div>Hello World</div>`
+     * ```
+     */
+    (strings: TemplateStringsArray, ...values: any[]): JSX.Element;
+    /**
+     * Self reference to tagged JSX instance for tooling
+     * @example
+     * ```tsx
+     * const MyComponent: FunctionComponent = (props) => {
+     *   // Use html to create a template inside a component
+     *   return myTaggedJSX.jsx`<div>Hello ${props.name}</div>`
+     * ```
+     */
+    jsx: TaggedJSXInstance<T>;
+    /**
+     * Create a new tagged JSX instance with additional components added to the registry
+     * @param components New components to add to the registry
+     * @example
+     * ```tsx
+     * const MyComponent: FunctionComponent = (props) => <div>Hello {props.name}</div>
+     * const myTaggedJSX = html.define({MyComponent})
+     * const myTemplate = myTaggedJSX`<MyComponent name="World" />`
+     * ```
+     */
+    define<TNew extends ComponentRegistry>(components: TNew): TaggedJSXInstance<T & TNew>;
+    /**
+     * Component registry
+     */
+    components: T;
+};

package/types-cjs/index.d.cts

@@ -1,3 +1 @@
-import type { TaggedJSXInstance } from "./tagged-jsx.cjs";
-declare const html: TaggedJSXInstance<{}>;
-export default html;
+export { default, type TaggedJSXInstance, type ComponentRegistry, type FunctionComponent } from "./tagged-jsx.cjs";

package/types-cjs/parse.d.cts

@@ -0,0 +1,67 @@
+import { Token } from "./tokenize.cjs";
+export declare const ROOT_NODE = 0;
+export declare const ELEMENT_NODE = 1;
+export declare const COMPONENT_NODE = 2;
+export declare const TEXT_NODE = 3;
+export declare const EXPRESSION_NODE = 4;
+export declare const BOOLEAN_PROP = 0;
+export declare const STATIC_PROP = 1;
+export declare const EXPRESSION_PROP = 2;
+export declare const SPREAD_PROP = 3;
+export type NodeType = typeof ROOT_NODE | typeof ELEMENT_NODE | typeof COMPONENT_NODE | typeof TEXT_NODE | typeof EXPRESSION_NODE;
+export type PropType = typeof BOOLEAN_PROP | typeof STATIC_PROP | typeof EXPRESSION_PROP | typeof SPREAD_PROP;
+export type ChildNode = ElementNode | TextNode | ExpressionNode | ComponentNode;
+export interface RootNode {
+    type: typeof ROOT_NODE;
+    children: ChildNode[];
+}
+export interface ElementNode {
+    type: typeof ELEMENT_NODE;
+    name: string;
+    props: PropNode[];
+    children: ChildNode[];
+    template?: HTMLTemplateElement;
+    /**
+     * Element-claim contract target (`a[href]`, `form[action]`, or a spread
+     * that may carry those). Stamped at template build — before static props
+     * are filtered out — so clones can be claimed even when the attribute was
+     * baked into the template.
+     */
+    claim?: boolean;
+}
+export interface ComponentNode {
+    type: typeof COMPONENT_NODE;
+    name: string | number;
+    props: PropNode[];
+    children: ChildNode[];
+}
+export interface TextNode {
+    type: typeof TEXT_NODE;
+    value: string;
+}
+export interface ExpressionNode {
+    type: typeof EXPRESSION_NODE;
+    value: number;
+}
+export interface BooleanProp {
+    name: string;
+    type: typeof BOOLEAN_PROP;
+    value: boolean;
+}
+export interface StringProp {
+    name: string;
+    type: typeof STATIC_PROP;
+    value: string;
+    quote?: "'" | '"';
+}
+export interface ExpressionProp {
+    name: string;
+    type: typeof EXPRESSION_PROP;
+    value: number;
+}
+export interface SpreadProp {
+    type: typeof SPREAD_PROP;
+    value: number;
+}
+export type PropNode = BooleanProp | StringProp | ExpressionProp | SpreadProp;
+export declare const parse: (tokens: Token[], voidElements: Set<string>) => RootNode;