@expressive/react/dist/jsx-runtime.d.ts

Use classes to define state in React!

import { Model } from '@expressive/mvc';
import React__default from 'react';
export { Fragment } from 'react';

declare module "@expressive/mvc" {
    namespace Model {
        namespace FC {
            type Extends<T extends Model, P extends {} = {}> = Props<T> & P;
            export type { Extends as Props };
        }
        /**
         * Use this to define a component which wraps a Model, intended to forward props.
         * This is to be used explicity, in JSDoc types or type annotations.
         * The second type parameter is additional props the component expects to receive.
         *
         * @example
         * ```tsx
         * import { Model } from '@expressive/react';
         *
         * class MyModel extends Model {
         *   foo: string;
         *   bar: number;
         * }
         *
         * const MyComponent: Model.FC<MyModel, { label: string }> =
         *   ({ label, ...rest }) => (
         *     <div>
         *      <span>{label}</span>
         *      <MyModel {...rest} />
         *     </div>
         *   );
         * ```
         */
        type FC<T extends Model, P extends {} = {}> = React__default.FC<FC.Props<T, P>>;
        /** Model which is not incompatable as Component in React. */
        interface Compat extends Model {
            render?(props: HasProps<this>, self: this): React__default.ReactNode;
        }
        interface BaseProps<T extends Model> {
            /**
             * Callback for newly created instance. Only called once.
             * @returns Callback to run when instance is destroyed.
             */
            is?: (instance: T) => void | (() => void);
            render?(props: HasProps<T>, self: T): React__default.ReactNode;
        }
        type HasProps<T extends Model> = Partial<Pick<T, Exclude<keyof T, keyof Model>>>;
        type Props<T extends Model> = T extends {
            render(props: infer P, self: any): any;
        } ? BaseProps<T> & HasProps<T> & P : BaseProps<T> & HasProps<T> & {
            children?: React__default.ReactNode;
        };
    }
}
declare namespace JSX {
    type ElementType = Model.Type<Model.Compat> | React__default.JSX.ElementType | ((props: {}, ref?: any) => void);
    type LibraryManagedAttributes<C, P> = C extends new (...args: any[]) => {
        props: infer U;
    } ? U : C extends Model.Type<infer U> ? Model.Props<U> : React__default.JSX.LibraryManagedAttributes<C, P>;
    interface Element extends React__default.JSX.Element {
    }
    interface ElementClass extends React__default.JSX.ElementClass {
    }
    interface ElementAttributesProperty {
    }
    interface ElementChildrenAttribute extends React__default.JSX.ElementChildrenAttribute {
    }
    interface IntrinsicAttributes extends React__default.JSX.IntrinsicAttributes {
    }
    interface IntrinsicClassAttributes<T> extends React__default.JSX.IntrinsicClassAttributes<T> {
    }
    interface IntrinsicElements extends React__default.JSX.IntrinsicElements {
    }
}
declare function compat(this: (type: React__default.ElementType, ...args: any[]) => React__default.ReactElement, type: React__default.ElementType | Model.Init, ...args: any[]): React__default.ReactElement;
declare const jsx: (type: React__default.ElementType<any, keyof React__default.JSX.IntrinsicElements> | Model.Init<Model>, ...args: any[]) => React__default.ReactElement<any, string | React__default.JSXElementConstructor<any>>;
declare const jsxs: (type: React__default.ElementType<any, keyof React__default.JSX.IntrinsicElements> | Model.Init<Model>, ...args: any[]) => React__default.ReactElement<any, string | React__default.JSXElementConstructor<any>>;

export { JSX, compat, jsx, jsxs };