@domyjs/domy 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,944 @@
+type AppState = {
+    isSetuped: boolean;
+    isMounted: boolean;
+    isUnmounted: boolean;
+};
+type App = () => Record<string, unknown> | void;
+type State = {
+    data: Record<string, unknown>;
+    componentInfos?: ComponentInfos;
+    refs: Record<string, Element>;
+};
+declare namespace ReactiveUtils {
+    /* eslint @typescript-eslint/no-this-alias: "off" */
+    type Listener = OnGetListener | OnSetListener;
+    type OnGetListener = {
+        type: "onGet";
+        fn: (props: {
+            reactiveVariable: ReactiveVariable;
+            path: string;
+        }) => void;
+    };
+    type OnSetListener = {
+        type: "onSet";
+        fn: (props: {
+            reactiveVariable: ReactiveVariable;
+            path: string;
+            prevValue: any;
+            newValue: any;
+        }) => void | Promise<void>;
+    };
+    const isProxySymbol: unique symbol;
+    const isSignalSymbol: unique symbol;
+    const skipReactivitySymbol: unique symbol;
+    /**
+     * Allow to create a DeepProxy to listen to any change into an object
+     * @author yoannchb-pro
+     */
+    class ReactiveVariable {
+        private target;
+        name: string;
+        private proxy;
+        private onSetListeners;
+        private onGetListeners;
+        static IS_GLOBAL_LOCK: boolean;
+        constructor(target: any);
+        getProxy(): any;
+        /**
+         * Check if the current target is already a proxy
+         * @param target
+         * @returns
+         */
+        static isReactive(target: any): boolean;
+        /**
+         * Check if the current target is a signal instead of a reactive
+         * @param target
+         * @returns
+         */
+        static isSignal(target: any): boolean;
+        /**
+         * Check we should skip the reactivity on the current element
+         * @param target
+         * @returns
+         */
+        static shouldBeSkip(target: any): boolean;
+        clearListeners(): void;
+        attachListener(l: Listener): () => void;
+        removeListener(l: Listener): void;
+        private canAttachProxy;
+        private isCollection;
+        private createCollectionHandler;
+        private createHandler;
+        private createProxy;
+        private callOnGetListeners;
+        private callOnSetListeners;
+    }
+    /**
+     * Attach a listener to all reactive variables
+     * @param listener
+     *
+     * @author yoannchb-pro
+     */
+    function globalWatch(listener: Listener, tracking?: boolean): () => void;
+    /**
+     * Will return true if a obj is a signal/reactive
+     * @param obj
+     * @returns
+     *
+     * @author yoannchb-pro
+     */
+    function isReactive(obj: any): boolean;
+    /**
+     * Will return true if the obj is a signal
+     * @param obj
+     * @returns
+     *
+     * @author yoannchb-pro
+     */
+    function isSignal(obj: any): boolean;
+    type MatchingResult = {
+        isMatching: boolean;
+        params: Record<string, string>;
+    };
+    /**
+     * Check if a path match a certain rule
+     * Example:
+     * path: todos.0.isComplete
+     * reg: todos.*.isComplete or todos, todos.* or todos.*.*
+     * Will give true
+     * reg: todos.1.isComplete, todos.*.name, todos.*.*.id
+     * Will give false
+     * @param reg
+     * @param path
+     * @returns
+     *
+     * @author yoannchb-pro
+     */
+    function matchPath(reg: string, path: string): MatchingResult;
+    /**
+     * Transform an object into a reactive object to listen to any change
+     * @param obj
+     * @returns
+     *
+     * @author yoannchb-pro
+     */
+    function reactive<T>(obj: T): T;
+    /**
+     * Register a name for a reactive variable
+     * It allow us to have a correct path name
+     * Example of use case:
+     * cont count = signal(0);
+     * watch(({ path }) => console.log(path), [count]);
+     * count.value += 1;
+     *
+     * The path is going to be "value" instead of "count.value" because we don't know the variable name
+     * So to fixe that we just need to put registerName("count", count) after the variable declaration
+     * @param name
+     * @param obj
+     * @returns
+     *
+     * @author yoannchb-pro
+     */
+    function registerName(name: string, obj: any): void;
+    /**
+     * Transform a primitive into a reactive object to listen to any change
+     * @param obj
+     * @returns
+     *
+     * @author yoannchb-pro
+     */
+    function signal<T>(obj: T): {
+        value: T;
+    };
+    /**
+     * Attach a listener to some reactives variables
+     * @param listener
+     * @param effect
+     *
+     * @author yoannchb-pro
+     */
+    function watch(listener: Listener, effect: () => any): () => void;
+    /**
+     * Allow us to lock every watcher if we need to do a set/get action on the object without calling the watcher
+     *
+     * @author yoannchb-pro
+     */
+    function lockWatchers(): void;
+    /**
+     * Unlock every watchers
+     *
+     * @author yoannchb-pro
+     */
+    function unlockWatchers(): void;
+    /**
+     * Will delete the reactivity of a data
+     * @param obj
+     * @returns
+     *
+     * @author yoannchb-pro
+     */
+    function unReactive<T = any>(obj: T): T;
+    /**
+     * Skip the reactivity on an element we don't wanna listen to in a reactivity variable
+     * Example:
+     * const myElement = reactive({ el: skipReactive({ ... }), name: 'div' })
+     * @param obj
+     * @returns
+     *
+     * @author yoannchb-pro
+     */
+    function skipReactive<T = any>(obj: T): T;
+    type Effect = () => any;
+    type UnEffect = () => void;
+    type WatchEffectOptions = {
+        noSelfUpdate?: boolean; // Avoid the effect to launch the function again
+        onDepChange?: (uneffect: UnEffect) => void;
+    };
+    /**
+     * Act like a watcher but get his dependencies it self by running one time the instance
+     * Example:
+     * const todo = reactive({ title: "Yoann", isCompleted: false });
+     * const uneffect = watchEffect(() => console.log(todo.title)); // Will display: "Yoann" when initialising
+     * todo.isCompleted = true; // Don't call the effect
+     * todo.title = "Pierre"; // Will call the effect and display "Pierre"
+     * @param effectFn
+     *
+     * @author yoannchb-pro
+     */
+    function watchEffect(effect: Effect, opts?: WatchEffectOptions): UnEffect;
+    type Dep = {
+        type: "reactive_variable_creation";
+        reactiveVariable: ReactiveVariable;
+        clean: () => void;
+    } | {
+        type: "watcher" | "effect" | "global_watcher";
+        clean: () => void;
+    };
+    let trackCallback: ((dep: Dep) => void) | null;
+    /**
+     * Allow us to track inside a function:
+     * - reactive variable (signal + reactive)
+     * - watcher
+     * - effects
+     * - global watchers
+     * @param fn
+     * @returns
+     *
+     * @author yoannchb-pro
+     */
+    function trackDeps(fn: () => any): Dep[];
+    const isComputedSymbol: unique symbol;
+    /**
+     * Will return a boolean determining if an object is a computed value or not
+     * @param obj
+     * @returns
+     *
+     * @author yoannchb-pro
+     */
+    function isComputed(obj: any): boolean;
+    /**
+     * Create a computed variable based on a signal
+     * Example:
+     * const count = signal(1);
+     * const doubleCount = computed(() => count.value * 2);
+     * console.log(doubleCount); // 2
+     * @param getter
+     * @param setter
+     * @returns
+     *
+     * @author yoannchb-pro
+     */
+    function computed<T extends () => unknown, R extends ReturnType<T>>(getter: () => R, setter?: (newValue: R) => void): {
+        [isComputedSymbol]: boolean;
+        value: R;
+    };
+}
+type Config = {
+    avoidDeprecatedWith?: boolean;
+    CSP?: boolean;
+};
+type Props = {
+    domyHelperId?: number;
+    el?: Element | Text;
+    state: State;
+    scopedNodeData: Record<string, any>[];
+    config: Config;
+    pluginHelper: PluginHelper;
+};
+/**
+ * Return a context with all what domy need to render
+ * Like variables, methods, helpers ...
+ * @param el
+ * @param state
+ * @param scopedNodeData
+ * @returns
+ *
+ * @author yoannchb-pro
+ */
+declare function getContext(props: Props): {
+    [x: `$${string}`]: any;
+};
+type QueueElement = () => any;
+/**
+ * Scheduler function to add a job to the queue
+ * @param job
+ *
+ * @author yoannchb-pro
+ */
+declare function queueJob(job: QueueElement, id: number): void;
+/**
+ * Return an unique queue id
+ * @returns
+ *
+ * @author yoannchb-pro
+ */
+declare function getUniqueQueueId(): number;
+/**
+ * Call a function with error handling
+ * @param fn
+ * @returns
+ *
+ * @author yoannchb-pro
+ */
+declare function callWithErrorHandling<T extends (...args: any[]) => any>(fn: T, onError?: (err: any) => void): {
+    hasError: true;
+    err: any;
+} | {
+    hasError: false;
+    result: ReturnType<T>;
+};
+/**
+ * Fixe an attribute name to avoid setAttribute throwing error
+ * @param attrName
+ * @returns
+ *
+ * @author yoannchb-pro
+ */
+declare function fixeAttrName(attrName: string): string;
+/**
+ * Retrieve some utils informations from a domy attribute
+ * @param attr
+ * @returns
+ *
+ * @author yoannchb-pro
+ */
+declare function getDomyAttributeInformations(attr: Attr): {
+    prefix: string;
+    directive: string;
+    modifiers: string[];
+    attrName: string;
+};
+/**
+ * Execute a function after the animation/transition on an element is finish
+ * @param el
+ * @param action
+ * @returns
+ *
+ * @author yoannchb-pro
+ */
+declare function executeActionAfterAnimation(el: Element, action: () => void): () => void;
+/**
+ * Get function (like get in lodash)
+ * @param object
+ * @param path
+ * @param defaultValue
+ * @returns
+ *
+ * @author yoannchb-pro
+ */
+declare function get<T = any>(object: Array<any> | Record<string, any>, path: string, defaultValue?: any): T | undefined;
+/**
+ * Set function (like set in lodash)
+ * @param object
+ * @param path
+ * @param value
+ * @returns
+ *
+ * @author yoannchb-pro
+ */
+declare function set<T>(object: T, path: string, value: any): T;
+type Props$0 = {
+    shouldBeDisplay: () => boolean;
+    domy: DomyDirectiveHelper;
+};
+/**
+ * Handle the visibility of an element with the transition
+ * @param props
+ * @returns
+ *
+ * @author yoannchb-pro
+ */
+declare function getElementVisibilityHandler(props: Props$0): {
+    effect: () => void;
+    cleanup: () => void;
+};
+/**
+ * Return the list of previous conditions elements before an element
+ * Useful for d-else and d-else-if directives
+ * @param element
+ * @param previousAuthorizedAttrs
+ * @returns
+ *
+ * @author yoannchb-pro
+ */
+declare function getPreviousConditionsElements(element: HTMLElement, previousAuthorizedAttrs: string[]): Element[];
+/**
+ * Return the get and set method for a reactive variable
+ * It allow us to keep the proxy and to handle signals
+ * @param obj
+ * @param key
+ * @returns
+ *
+ * @author yoannchb-pro
+ */
+declare function getReactiveHandler(obj: Record<string, any>, key: string): PropertyDescriptor;
+/**
+ * Handle class attribute if it's a string or an object like
+ * { show: true }
+ * or
+ * ["show"]
+ * @param executedValue
+ * @param defaultClass
+ *
+ * @author yoannchb-pro
+ */
+declare function handleClass(executedValue: any, defaultClass?: string): {
+    class: string;
+    cleanedClass: (newDefaultClass: string) => string;
+};
+/**
+ * Handle style attribute if it's an object
+ * { backgroundColor: '#fff', color: 'red' .... }
+ * @param executedValue
+ * @param defaultStyle
+ *
+ * @author yoannchb-pro
+ */
+declare function handleStyle(executedValue: any, defaultStyle?: string): {
+    style: string;
+    cleanedStyle: (newDefaultStyle: string) => string;
+};
+/**
+ * Check if the current attribute is a binding attribute
+ * @param attr
+ * @returns
+ *
+ * @author yoannchb-pro
+ */
+declare function isBindAttr(attr: string): boolean;
+/**
+ * Check if the current attribute is an event attribute
+ * @param attr
+ * @returns
+ *
+ * @author yoannchb-pro
+ */
+declare function isEventAttr(attr: string): boolean;
+declare function isDNameAttr(attr: string): boolean;
+/**
+ * Check if the current attribute is a domy attribute
+ * It could be a prefix like d-on:click
+ * Or it could be a simple attribute like d-for
+ * @param attr
+ * @returns
+ *
+ * @author yoannchb-pro
+ */
+declare function isDomyAttr(PLUGINS: Plugins, attr: string): boolean;
+/**
+ * Check if the current attribute is a normal attribute
+ * @param attr
+ * @returns
+ *
+ * @author yoannchb-pro
+ */
+declare function isNormalAttr(PLUGINS: Plugins, attr: string): boolean;
+/**
+ * Convert a kebab string into a camelCase string
+ * Example: show-error -> showError
+ * @param str
+ * @returns
+ *
+ * @author yoannchb-pro
+ */
+declare function kebabToCamelCase(str: string): string;
+/**
+ * Warn log function for domy
+ * @param msg
+ *
+ * @author yoannchb-pro
+ */
+declare function warn(msg: string): void;
+/**
+ * Error log function for domy
+ * @param err
+ *
+ * @author yoannchb-pro
+ */
+declare function error(...errs: (Error | string)[]): void;
+/**
+ * Allow us to merge conditions for d-else and d-else-if
+ * @param conditions
+ * @returns
+ *
+ * @author yoannchb-pro
+ */
+declare function mergeToNegativeCondition(conditions: string[]): string;
+/**
+ * Convert a string to kebab case
+ * Example:
+ * console.log(toKebabCase('HelloWorld'));        // hello-world
+ * console.log(toKebabCase('myVariableName'));    // my-variable-name
+ * console.log(toKebabCase('Hello World Today')); // hello-world-today
+ * @param str
+ * @returns
+ *
+ * @author yoannchb-pro
+ */
+declare function toKebabCase(str: string): string;
+// A list of utils we can access in helpers
+declare const helpersUtils: {
+    handleClass: typeof handleClass;
+    handleStyle: typeof handleStyle;
+    callWithErrorHandling: typeof callWithErrorHandling;
+    toKebabCase: typeof toKebabCase;
+    kebabToCamelCase: typeof kebabToCamelCase;
+    getElementVisibilityHandler: typeof getElementVisibilityHandler;
+    get: typeof get;
+    set: typeof set;
+    getPreviousConditionsElements: typeof getPreviousConditionsElements;
+    executeActionAfterAnimation: typeof executeActionAfterAnimation;
+    getReactiveHandler: typeof getReactiveHandler;
+    mergeToNegativeCondition: typeof mergeToNegativeCondition;
+    fixeAttrName: typeof fixeAttrName;
+    getDomyAttributeInformations: typeof getDomyAttributeInformations;
+    isDomyAttr: typeof isDomyAttr;
+    isNormalAttr: typeof isNormalAttr;
+    isEventAttr: typeof isEventAttr;
+    isBindAttr: typeof isBindAttr;
+    isDNameAttr: typeof isDNameAttr;
+    warn: typeof warn;
+    error: typeof error;
+};
+type Helpers = Record<`$${string}`, any>;
+type Props$1 = {
+    domyHelperId?: number;
+    el?: Element | Text;
+    state: State;
+    config: Config;
+    scopedNodeData: Record<string, any>[];
+    pluginHelper: PluginHelper;
+};
+/**
+ * Return the initialised helpers with everything it need
+ * @param el
+ * @param state
+ * @param scopedNodeData
+ * @returns
+ *
+ * @author yoannchb-pro
+ */
+declare function getHelpers(props: Props$1): Helpers;
+type Options = {
+    dontQueueOnFirstExecution?: boolean;
+    effectId?: number;
+};
+/**
+ * Allow to queue an effect
+ * @param effect
+ * @param opts
+ *
+ * @author yoannchb-pro
+ */
+declare function queuedWatchEffect(effect: () => any, opts?: Options): () => void;
+// A list of utils we can access in directives/prefix
+declare const directivesUtils: {
+    getHelpers: typeof getHelpers;
+    queuedWatchEffect: typeof queuedWatchEffect;
+    handleClass: typeof handleClass;
+    handleStyle: typeof handleStyle;
+    callWithErrorHandling: typeof callWithErrorHandling;
+    toKebabCase: typeof toKebabCase;
+    kebabToCamelCase: typeof kebabToCamelCase;
+    getElementVisibilityHandler: typeof getElementVisibilityHandler;
+    get: typeof get;
+    set: typeof set;
+    getPreviousConditionsElements: typeof getPreviousConditionsElements;
+    executeActionAfterAnimation: typeof executeActionAfterAnimation;
+    getReactiveHandler: typeof getReactiveHandler;
+    mergeToNegativeCondition: typeof mergeToNegativeCondition;
+    fixeAttrName: typeof fixeAttrName;
+    getDomyAttributeInformations: typeof getDomyAttributeInformations;
+    isDomyAttr: typeof isDomyAttr;
+    isNormalAttr: typeof isNormalAttr;
+    isEventAttr: typeof isEventAttr;
+    isBindAttr: typeof isBindAttr;
+    isDNameAttr: typeof isDNameAttr;
+    warn: typeof warn;
+    error: typeof error;
+};
+type Observer = {
+    type: keyof AppState;
+    callback: () => void;
+};
+/**
+ * Register the current lifecycle state of the current app
+ *
+ * @author yoannchb-pro
+ */
+declare class AppStateObserver {
+    private observers;
+    private appState;
+    get isMounted(): boolean;
+    get isSetuped(): boolean;
+    get isUnmounted(): boolean;
+    set isMounted(newValue: boolean);
+    set isSetuped(newValue: boolean);
+    set isUnmounted(newValue: boolean);
+    private callObservers;
+    addObserver(observer: Observer): () => void;
+    removeObserver(observer: Observer): void;
+}
+type Transition = {
+    enterTransition: string;
+    enterTransitionTo: string;
+    outTransition: string;
+    outTransitionTo: string;
+    init: boolean;
+};
+type TransitionType = "enterTransition" | "outTransition";
+/**
+ * Utilitary class to handle properly an element
+ */
+declare class Block {
+    private element;
+    name: string | null;
+    key: string | null;
+    private pluginsData;
+    transition: Transition | null;
+    private cleanupTransition;
+    private cleanups;
+    private onElChangeCbList;
+    parentBlock: Block | null;
+    constructor(element: Element | Block);
+    getDataForPluginId(pluginId: string): any;
+    setDataForPluginId(pluginId: string, data: any): void;
+    cleanTransition(): void;
+    private callCbForElementChange;
+    createNewElementBlock(): Block;
+    attachListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    onElementChange(cb: (newEl: Element) => void): void;
+    setEl(newEl: Element | Block): void;
+    getEl(): Element;
+    applyTransition(transitionType: TransitionType, action?: () => void): void;
+    replaceWith(newEl: Element | Block): void;
+    remove(): void;
+    isTemplate(): boolean;
+    isTextNode(): boolean;
+    addCleanup(cleanup: () => void): void;
+    unmount(): void;
+}
+type Props$2 = {
+    element: Element | Block;
+    scopedNodeData: Record<string, any>[];
+    byPassAttributes?: string[];
+    skipChildRendering?: boolean;
+    renderWithoutListeningToChange?: boolean;
+};
+/**
+ * Deep render an element (with the childs and textContent)
+ * It will keep the config for all the specified target only
+ * @param config
+ *
+ * @author yoannchb-pro
+ */
+declare function createDeepRenderFn(appId: number, appState: AppStateObserver, state: State, config: Config, components: Components, pluginHelper: PluginHelper): (props: Props$2) => Block;
+type DomyDirectiveFn = (domy: DomyDirectiveHelper) => DomyDirectiveReturn;
+type DomySpecialFn = (domy: DomySpecialHelper) => any;
+type DomyDirectiveReturn = {
+    skipChildsRendering?: boolean;
+    skipOtherAttributesRendering?: boolean;
+    skipComponentRendering?: boolean;
+} | void;
+type DomySpecialHelper = {
+    domyHelperId?: number;
+    el?: Element | Text;
+    state: State;
+    scopedNodeData: Record<string, any>[];
+    config: Config;
+    utils: typeof helpersUtils;
+} & typeof ReactiveUtils;
+type DomyDirectiveHelper = {
+    domyHelperId: number;
+    pluginHelper: PluginHelper;
+    appState: AppStateObserver;
+    block: Block;
+    config: Config;
+    state: State;
+    scopedNodeData: Record<string, any>[];
+    prefix: string;
+    directive: string;
+    modifiers: string[];
+    attrName: string;
+    attr: {
+        name: string;
+        value: string;
+    };
+    utils: typeof directivesUtils;
+    onElementMounted(cb: () => void): void;
+    onAppMounted(cb: () => void): void;
+    getUniqueQueueId: typeof getUniqueQueueId;
+    queueJob: typeof queueJob;
+    effect(cb: () => void): (() => void) | void;
+    cleanup(cb: () => void): void;
+    evaluate(code: string, scope?: Record<string, any>): any;
+    deepRender: ReturnType<typeof createDeepRenderFn>;
+    addScopeToNode(obj: Record<string, any>): void;
+    removeScopeToNode(obj: Record<string, any>): void;
+    getContext: typeof getContext;
+} & typeof ReactiveUtils;
+type DomyPluginDefinition = {
+    prefix(name: string, fn: DomyDirectiveFn): void;
+    directive(name: string, fn: DomyDirectiveFn): void;
+    helper(name: string, fn: DomySpecialFn): void;
+};
+type DomyPlugin = (domy: DomyPluginDefinition) => void;
+type PluginHelper = ReturnType<typeof createPluginRegistrer>;
+type Plugins = {
+    prefixes: Record<string, DomyDirectiveFn>;
+    directives: Record<string, DomyDirectiveFn>;
+    helpers: Record<string, DomySpecialFn>;
+};
+/**
+ * Allow to register plugin for the current instance
+ * @returns
+ *
+ * @author yoannchb-pro
+ */
+declare function createPluginRegistrer(): {
+    PLUGINS: Plugins;
+    plugin: (pluginMaker: DomyPlugin) => void;
+};
+type ComponentInfos = {
+    componentData: {
+        $props: {
+            [key: string]: any;
+        };
+        $attrs: {
+            [key: string]: string;
+        };
+    };
+    childrens: Element[];
+    names: {
+        [name: string]: Element | undefined;
+    };
+    parentPluginHelper: PluginHelper;
+};
+type Component = (props: {
+    name: string;
+    componentElement: HTMLElement;
+    domy: DomyDirectiveHelper;
+}) => void | (() => Element);
+type Components = {
+    [name: string]: Component;
+};
+type ComponentDefinition = {
+    html: string;
+    props?: string[];
+    app?: App;
+    components?: Components;
+};
+/**
+ * Get the render function after mounting a DOMY app
+ * It allow the user to append html element
+ * Example:
+ * const p = document.createElement('p');
+ * p.textContent = 'Count: {{ count }}';
+ * app.render(p);
+ * container.appendChild(p);
+ * @param deepRender
+ * @param state
+ * @returns
+ *
+ * @author yoannchb-pro
+ */
+declare function getRender(deepRender: ReturnType<typeof createDeepRenderFn>): (element: Element) => Block;
+/**
+ * Same as createAdvancedApp but the user can't inject data or methods
+ * @param appDefinition
+ * @returns
+ *
+ * @author yoannchb-pro
+ */
+declare function createApp(appDefinition?: App): {
+    appId: number;
+    mount: (target?: HTMLElement) => {
+        render: ReturnType<typeof getRender>;
+        unmount: () => void;
+    };
+    configure: (c: Config) => {
+        plugins: (pluginsList: DomyPlugin[]) => {
+            components: (c: Components) => {
+                mount: (target?: HTMLElement) => {
+                    render: ReturnType<typeof getRender>;
+                    unmount: () => void;
+                };
+            };
+            mount: (target?: HTMLElement) => {
+                render: ReturnType<typeof getRender>;
+                unmount: () => void;
+            };
+        };
+        components: (c: Components) => {
+            mount: (target?: HTMLElement) => {
+                render: ReturnType<typeof getRender>;
+                unmount: () => void;
+            };
+        };
+        mount: (target?: HTMLElement) => {
+            render: ReturnType<typeof getRender>;
+            unmount: () => void;
+        };
+    };
+    components: (c: Components) => {
+        mount: (target?: HTMLElement) => {
+            render: ReturnType<typeof getRender>;
+            unmount: () => void;
+        };
+    };
+    plugins: (pluginsList: DomyPlugin[]) => {
+        components: (c: Components) => {
+            mount: (target?: HTMLElement) => {
+                render: ReturnType<typeof getRender>;
+                unmount: () => void;
+            };
+        };
+        mount: (target?: HTMLElement) => {
+            render: ReturnType<typeof getRender>;
+            unmount: () => void;
+        };
+    };
+};
+/**
+ * Allow the user to create component
+ * This function get the component without the directives which has already been rendered
+ * Example:
+ * createComponent({
+ *  props: ['title'],
+ *  html: `
+ *  <div>
+ *    <h1>{{ $props.title }}</h1>
+ *    <p>Count: {{ count }}</p>
+ *    <button @click="++count">+</button>
+ *    <button @click="--count">-</button>
+ *  </div>
+ * `,
+ *  app(){
+ *     const count = signal(0);
+ *     return { count };
+ *  }
+ * })
+ * @param componentDefinition
+ * @returns
+ *
+ * @author yoannchb-pro
+ */
+declare function createComponent(componentDefinition: ComponentDefinition): Components[keyof Components];
+/* eslint @typescript-eslint/no-this-alias: "off" */
+type Listener = OnGetListener | OnSetListener;
+type OnGetListener = {
+    type: "onGet";
+    fn: (props: {
+        reactiveVariable: ReactiveVariable;
+        path: string;
+    }) => void;
+};
+type OnSetListener = {
+    type: "onSet";
+    fn: (props: {
+        reactiveVariable: ReactiveVariable;
+        path: string;
+        prevValue: any;
+        newValue: any;
+    }) => void | Promise<void>;
+};
+/**
+ * Allow to create a DeepProxy to listen to any change into an object
+ * @author yoannchb-pro
+ */
+declare class ReactiveVariable {
+    private target;
+    name: string;
+    private proxy;
+    private onSetListeners;
+    private onGetListeners;
+    static IS_GLOBAL_LOCK: boolean;
+    constructor(target: any);
+    getProxy(): any;
+    /**
+     * Check if the current target is already a proxy
+     * @param target
+     * @returns
+     */
+    static isReactive(target: any): boolean;
+    /**
+     * Check if the current target is a signal instead of a reactive
+     * @param target
+     * @returns
+     */
+    static isSignal(target: any): boolean;
+    /**
+     * Check we should skip the reactivity on the current element
+     * @param target
+     * @returns
+     */
+    static shouldBeSkip(target: any): boolean;
+    clearListeners(): void;
+    attachListener(l: Listener): () => void;
+    removeListener(l: Listener): void;
+    private canAttachProxy;
+    private isCollection;
+    private createCollectionHandler;
+    private createHandler;
+    private createProxy;
+    private callOnGetListeners;
+    private callOnSetListeners;
+}
+declare const DOMY$0: {
+    createApp: typeof createApp;
+    createComponent: typeof createComponent;
+    onSetuped: (cb: () => void | Promise<void>) => void;
+    onMounted: (cb: () => void | Promise<void>) => void;
+    onBeforeUnmount: (cb: () => void | Promise<void>) => void;
+    onUnmounted: (cb: () => void | Promise<void>) => void;
+    useAttrs: () => {
+        [key: string]: string;
+    } | undefined;
+    useProps: () => {
+        [key: string]: any;
+    } | undefined;
+    useChildrens: () => Element[] | undefined;
+    useConfig: () => Config;
+    useNames: () => {
+        [name: string]: Element | undefined;
+    } | undefined;
+    useRefs: () => {
+        [x: string]: Element;
+    };
+    nextTick: (cb?: () => void | Promise<void>) => Promise<unknown>;
+    watch: (listener: OnSetListener["fn"], effect: () => any) => () => void;
+    watchEffect: (effect: () => any) => () => void;
+    globalWatch: (listener: OnSetListener["fn"]) => () => void;
+    matchPath: typeof ReactiveUtils.matchPath;
+    signal: typeof ReactiveUtils.signal;
+    computed: typeof ReactiveUtils.computed;
+    skipReactive: typeof ReactiveUtils.skipReactive;
+    helperToHookRegistrer: {
+        getHook<T extends (domy: DomySpecialHelper) => any>(helper: T): () => ReturnType<T>;
+        provideHookMandatories(domyHelper: DomySpecialHelper): void;
+        clear(): void;
+    };
+};
+
+export { Block, DOMY$0 as DOMY, DOMY$0 as default };
+export type { App, AppState, Component, ComponentDefinition, ComponentInfos, Components, Config, DomyDirectiveFn, DomyDirectiveHelper, DomyDirectiveReturn, DomyPlugin, DomyPluginDefinition, DomySpecialFn, DomySpecialHelper, Helpers, State };