@italone/solace 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,115 @@
+import { C as ComponentType, V as VNode, a as VNodeProps, b as VNodeChildren, F as Fragment, c as ComponentVNodeChildren, d as VNodeType, e as ComponentRender, f as ComponentSetupContext } from './vnode-zJOgBYFm.js';
+export { g as ComponentProps, E as EmitFn, h as FragmentType, S as Slot, i as SlotProps, j as Slots, k as VNodeChild, l as VNodeSlots } from './vnode-zJOgBYFm.js';
+
+interface ComputedRef<T> {
+    readonly value: T;
+}
+declare function computed<T>(getter: () => T): ComputedRef<T>;
+
+type ProvideKey = string | symbol;
+type Provides = Map<ProvideKey, unknown>;
+declare function provide<T>(key: ProvideKey, value: T): void;
+declare function inject<T>(key: ProvideKey): T | undefined;
+declare function inject<T>(key: ProvideKey, defaultValue: T): T;
+
+declare function effect<T>(fn: () => T): () => T;
+
+type LifecycleHook = () => void;
+declare function onMounted(hook: LifecycleHook): void;
+declare function onUpdated(hook: LifecycleHook): void;
+declare function onUnmounted(hook: LifecycleHook): void;
+
+type PluginInstall = (app: App, ...options: unknown[]) => void;
+interface PluginObject {
+    install: PluginInstall;
+}
+type Plugin = PluginInstall | PluginObject;
+interface App {
+    mount(container: Element): void;
+    provide<T>(key: ProvideKey, value: T): App;
+    use(plugin: Plugin, ...options: unknown[]): App;
+}
+declare function createApp(rootComponent: ComponentType | VNode): App;
+
+declare function reactive<T extends object>(target: T): T;
+
+interface Ref<T> {
+    value: T;
+}
+declare function ref<T>(value: T): Ref<T>;
+
+type WatchSource<T> = () => T;
+type WatchCallback<T> = (newValue: T, oldValue: T) => void;
+type WatchEffect = () => void;
+type WatchStopHandle = () => void;
+declare function watch<T>(source: WatchSource<T>, callback: WatchCallback<T>): WatchStopHandle;
+declare function watchEffect(effect: WatchEffect): WatchStopHandle;
+
+declare function nextTick<T = void>(callback?: () => T): Promise<T | void>;
+
+type RenderSource = VNode | (() => VNode);
+declare function render(source: RenderSource, container: Element, appProvides?: Provides | null): void;
+
+declare function h(type: string, props?: VNodeProps | null, children?: VNodeChildren): VNode;
+declare function h(type: typeof Fragment, props?: VNodeProps | null, children?: VNodeChildren): VNode;
+declare function h<Props extends object>(type: ComponentType<Props>, props?: Props | null, children?: ComponentVNodeChildren): VNode;
+declare function h(type: VNodeType, props?: VNodeProps | null, children?: ComponentVNodeChildren): VNode;
+
+type AsyncComponentLoader<Props extends object> = () => Promise<ComponentType<Props>>;
+interface AsyncComponentOptions<Props extends object> {
+    loader: AsyncComponentLoader<Props>;
+    loadingComponent?: ComponentType<Props>;
+    errorComponent?: ComponentType<Props>;
+    delay?: number;
+    timeout?: number;
+    retry?: number;
+    retryDelay?: number;
+}
+type AsyncComponentSource<Props extends object> = AsyncComponentLoader<Props> | AsyncComponentOptions<Props>;
+declare function defineAsyncComponent<Props extends object>(source: AsyncComponentSource<Props>): ComponentType<Props>;
+
+declare function defineComponent<Props extends object, Result extends ComponentRender | VNode>(component: (props: Props, context: ComponentSetupContext) => Result): (props: Props, context: ComponentSetupContext) => Result;
+
+type StateFactory<State extends object> = () => State;
+type ActionTree<State extends object, GetterValues extends Record<string, unknown>> = Record<string, (context: StoreContext<State, GetterValues>, ...args: never[]) => unknown>;
+interface StoreGetterContext<State extends object> {
+    state: State;
+}
+type StoreGetters<State extends object, GetterValues extends Record<string, unknown>> = {
+    [Key in keyof GetterValues]: (context: StoreGetterContext<State>) => GetterValues[Key];
+};
+type StoreActionsInput<State extends object, GetterValues extends Record<string, unknown>> = ActionTree<State, GetterValues>;
+type StoreActionMethods<Actions> = {
+    [Key in keyof Actions]: Actions[Key] extends (context: never, ...args: infer Args) => infer Result ? (...args: Args) => Result : never;
+};
+interface StoreContext<State extends object, GetterValues extends Record<string, unknown> = Record<string, never>> {
+    state: State;
+    getters: Readonly<GetterValues>;
+}
+interface Store<State extends object, GetterValues extends Record<string, unknown> = Record<string, never>, Actions extends ActionTree<State, GetterValues> = Record<string, never>> extends StoreContext<State, GetterValues> {
+    actions: StoreActionMethods<Actions>;
+}
+interface StoreOptions<State extends object, GetterValues extends Record<string, unknown> = Record<string, never>, Actions extends ActionTree<State, GetterValues> = Record<string, never>> {
+    state: StateFactory<State>;
+    getters?: StoreGetters<State, GetterValues>;
+    actions?: Actions & StoreActionsInput<State, GetterValues>;
+}
+declare function createStore<State extends object>(options: {
+    state: StateFactory<State>;
+}): Store<State>;
+declare function createStore<State extends object, GetterValues extends Record<string, unknown>>(options: {
+    state: StateFactory<State>;
+    getters: StoreGetters<State, GetterValues>;
+}): Store<State, GetterValues>;
+declare function createStore<State extends object, Actions extends ActionTree<State, Record<string, never>>>(options: {
+    state: StateFactory<State>;
+    actions: Actions & StoreActionsInput<State, Record<string, never>>;
+}): Store<State, Record<string, never>, Actions>;
+declare function createStore<State extends object, GetterValues extends Record<string, unknown>, Actions extends ActionTree<State, GetterValues>>(options: {
+    state: StateFactory<State>;
+    getters: StoreGetters<State, GetterValues>;
+    actions: Actions & StoreActionsInput<State, GetterValues>;
+}): Store<State, GetterValues, Actions>;
+
+export { ComponentRender, ComponentSetupContext, ComponentType, ComponentVNodeChildren, Fragment, VNode, VNodeChildren, VNodeProps, VNodeType, computed, createApp, createStore, defineAsyncComponent, defineComponent, effect, h, inject, nextTick, onMounted, onUnmounted, onUpdated, provide, reactive, ref, render, watch, watchEffect };
+export type { App, AsyncComponentLoader, AsyncComponentOptions, AsyncComponentSource, Plugin, PluginInstall, PluginObject, Store, StoreActionsInput, StoreContext, StoreGetterContext, StoreGetters, StoreOptions };