@variousjs/various 6.0.0 → 6.1.0

package/dist/types/core/helper.d.ts

@@ -0,0 +1,44 @@
+import type { ModuleDef, VariousComponentType, ErrorType, ObjectRecord, GetModuleInfo, PreloadModules, RemoveLoadedModules, DefineDependencies, IsModuleLoaded, OnComponentMounted, VariousError as VariousErrorShape } from '../public/types';
+import { RequiredComponent } from '../types';
+import { setModule } from './system';
+export declare const getModuleInfo: GetModuleInfo;
+export declare const preloadModules: PreloadModules;
+export declare const removeLoadedModules: RemoveLoadedModules;
+export declare const defineDependencies: DefineDependencies;
+export declare const isModuleLoaded: IsModuleLoaded;
+export declare const isModuleSpecified: (module: ModuleDef) => boolean;
+export declare const getMountedComponents: () => ModuleDef[];
+export declare const onComponentMounted: OnComponentMounted;
+export declare const resetDependencyConfig: (module: ModuleDef, url?: string) => void;
+export declare function getConfig<C extends object = ObjectRecord>(): C;
+export declare const onError: (e: VariousError) => void;
+export declare class VariousError extends Error implements VariousErrorShape {
+    type: ErrorType;
+    originalError: Error;
+    module: ModuleDef;
+    constructor(data: {
+        module: ModuleDef;
+        type: ErrorType;
+        originalError: Error;
+    });
+}
+export declare function checkReactComponent(component: RequiredComponent, module: ModuleDef): Promise<void>;
+export declare function isPromiseLike<T>(value: T | PromiseLike<T>): value is PromiseLike<T>;
+export declare function checkVueComponent(component: RequiredComponent, module: ModuleDef): Promise<void>;
+export declare function parseComponentActions(params: {
+    module: ModuleDef;
+    componentNode: RequiredComponent;
+    type?: VariousComponentType;
+    i18nUpdate: () => void;
+}): () => void;
+export declare function updateMountedComponent(module: ModuleDef): void;
+export declare function updateUnMountComponent(module: ModuleDef): void;
+export declare function getSelfInfo(params: {
+    url?: string;
+    module: ModuleDef;
+}): {
+    module: string;
+    url: string;
+};
+export declare function getClassNameWithModule(module: ModuleDef, prefix: string): string;
+export { setModule };

package/dist/types/core/i18n.d.ts

@@ -0,0 +1,3 @@
+import type { Intl, ModuleDef, I18n } from '../public/types';
+export declare function createI18nConfig(method?: I18n, module?: ModuleDef, callback?: () => void): void;
+export declare function createI18n(module: ModuleDef, updater: () => void): Intl;

package/dist/types/core/index.d.ts

@@ -0,0 +1,63 @@
+import React from 'react';
+import type { App, Config } from '../public/types';
+import { Store } from '../types';
+export { default as Nycticorax } from 'nycticorax';
+export { getUserStore as getStore } from './store';
+export { default as createDispatch } from './dispatch';
+export { createPostMessage } from './message';
+export { default as createLogger } from './logger';
+export { getConfig, preloadModules, isModuleLoaded, getMountedComponents, onComponentMounted, defineDependencies, removeLoadedModules, getModuleInfo, } from './helper';
+export { default as createModule } from './create-module';
+export { default as createComponent } from './create-component';
+export { default as renderComponent } from './render-component';
+export declare const version: string;
+export declare const getApp: (config: Config & App<Store>) => {
+    new (props: {}): {
+        componentDidMount(): void;
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<{}>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<{}>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<{}>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<{}>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<{}>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: {}, context: any): {
+        componentDidMount(): void;
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<{}>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<{}>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<{}>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<{}>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<{}>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    displayName: string;
+    contextType?: React.Context<any> | undefined;
+};

package/dist/types/core/logger.d.ts

@@ -0,0 +1,3 @@
+import type { CreateLogger } from '../public/types';
+declare const createLogger: CreateLogger;
+export default createLogger;

package/dist/types/core/message.d.ts

@@ -0,0 +1,3 @@
+import type { ModuleDef, OnMessage, CreatePostMessage } from '../public/types';
+export declare const createPostMessage: CreatePostMessage;
+export declare const createOnMessage: (module: ModuleDef, onMessage: OnMessage) => () => void;

package/dist/types/core/react-component.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import type { ModuleDef } from '../public/types';
+declare function reactComponent<P extends object>(config: {
+    module: ModuleDef;
+    url?: string;
+    watchKeys?: string[];
+    onMounted?: () => void;
+}): React.ComponentType<{}> & {
+    [x: string]: any;
+};
+export default reactComponent;

package/dist/types/core/render-component.d.ts

@@ -0,0 +1,3 @@
+import type { RenderComponent } from '../public/types';
+declare const renderComponent: RenderComponent;
+export default renderComponent;

package/dist/types/core/store.d.ts

@@ -0,0 +1,22 @@
+import type { ObjectRecord } from '../public/types';
+import { Store } from '../types';
+import { MESSAGE_KEY, MOUNTED_COMPONENTS_KEY, CONFIG_KEY, DEPENDENCIES_KEY, LOCALE_KEY, STANDALONE_CONFIG_READY } from './config';
+export { MESSAGE_KEY, MOUNTED_COMPONENTS_KEY, CONFIG_KEY, DEPENDENCIES_KEY, LOCALE_KEY, STANDALONE_CONFIG_READY, };
+export declare const createStore: (state: Store) => void, getStore: <K extends keyof Store | undefined = undefined>(key?: K | undefined) => K extends keyof Store ? Store[K] : Store, connect: (...keys: (keyof Store)[]) => <P extends Store>(C: import("react").ComponentType<P> & {
+    [x: string]: any;
+}) => import("react").ComponentType<{ [P_1 in keyof P extends infer T_1 ? T_1 extends T_1 & keyof P ? T_1 extends keyof Store ? never : T_1 : never : never]: P[P_1]; }> & {
+    [x: string]: any;
+}, emit: (next: Partial<Store>, sync?: boolean) => void, subscribe: (listener: Partial<{
+    [x: string]: (newValue: any, oldValue: any) => void;
+    [MESSAGE_KEY]: (newValue: (import("../public/types").Message<never> & {
+        timestamp: number;
+    }) | null, oldValue: (import("../public/types").Message<never> & {
+        timestamp: number;
+    }) | null) => void;
+    [MOUNTED_COMPONENTS_KEY]: (newValue: string[], oldValue: string[]) => void;
+    [CONFIG_KEY]: (newValue: Record<string | symbol, any>, oldValue: Record<string | symbol, any>) => void;
+    [DEPENDENCIES_KEY]: (newValue: Record<string, string>, oldValue: Record<string, string>) => void;
+    [STANDALONE_CONFIG_READY]?: ((newValue: boolean | undefined, oldValue: boolean | undefined) => void) | undefined;
+    [LOCALE_KEY]: (newValue: string, oldValue: string) => void;
+}>) => () => void, dispatch: (next: import("nycticorax").Dispatch<Store>, ...params: any) => Promise<any>, useStore: (...keys: (keyof Store)[]) => Store;
+export declare function getUserStore<S extends object = ObjectRecord>(): S;

package/dist/types/core/system.d.ts

@@ -0,0 +1,22 @@
+type Registry = {
+    modules: Map<string, any>;
+    urls: Map<string, string>;
+    loaded: Map<string, any>;
+};
+declare global {
+    interface Window {
+        __various?: Registry;
+    }
+}
+export declare function getRegistry(): Registry;
+export declare function setModuleUrl(name: string, url: string): void;
+export declare function getModuleUrl(name: string): string | undefined;
+export declare function getAllModuleUrls(): Record<string, string>;
+export declare function getInjectedModuleNames(): string[];
+export declare function importModule<T = any>(name: string): Promise<T>;
+export declare function isModuleDefined(name: string): boolean;
+export declare function isModuleSpecified(name: string): boolean;
+export declare function deleteModule(name: string): void;
+export declare function setModule(name: string, mod: any): void;
+export declare function createModuleBlobUrl(name: string): string | null;
+export {};

package/dist/types/core/vue-component.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { ComponentDefaultProps, ModuleDef } from '../public/types';
+import { CreateComponentProps } from '../types';
+declare function vueComponent<P extends object>(config: {
+    module: ModuleDef;
+    url?: string;
+    watchKeys?: string[];
+    onMounted?: () => void;
+}): React.FC<CreateComponentProps<P> & ComponentDefaultProps<unknown>>;
+export default vueComponent;

package/dist/types/loader.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/public/index.d.ts

@@ -0,0 +1,4 @@
+export { default as Nycticorax } from 'nycticorax';
+export type { Dispatch } from 'nycticorax';
+export { createComponent, createModule, renderComponent, createDispatch, createPostMessage, createLogger, getConfig, getStore, getModuleInfo, preloadModules, isModuleLoaded, removeLoadedModules, getMountedComponents, onComponentMounted, defineDependencies, version, } from '../core';
+export type { ModuleDef, ObjectRecord, VariousComponentType, ErrorType, ComponentDefaultProps, VariousError, PublicAction, DefineActions, DefineMessages, StaticMethods, ComponentStatics, DefineAppActions, Intl, I18nConfig, I18n, GlobalI18n, OnMessage, VariousProps, VariousFC, ErrorFallbackProps, ErrorFallbackNode, FallbackProps, FallbackNode, MessageEvent, DispatchEvent, LoadEvent, ErrorEvent, LogEvent, App, Config, VariousComponentProps, } from './types';

package/dist/types/public/standalone.d.ts

@@ -0,0 +1,3 @@
+export { createDispatch, createLogger, createPostMessage } from './index';
+export { createComponent, createAppConfig } from '../standalone';
+export type { DependencyType, AppConfig } from './types';

package/dist/types/public/types.d.ts

@@ -0,0 +1,272 @@
+import { ComponentType, FC, ReactNode, RefObject } from 'react';
+import { PropType } from 'vue';
+/**
+* module name
+* - e.g. A.B
+* - e.g. B
+* - e.g. app
+* - e.g. A.default -> A
+*/
+export type ModuleDef = string;
+export type ObjectRecord<T = any> = Record<string, T>;
+export type VariousComponentType = 'react' | 'vue3';
+export type ErrorType = 'LOADING_ERROR' | 'SUBMODULE_LOADING_ERROR' | 'NOT_DEFINED' | 'INVALID_COMPONENT' | 'SCRIPT_ERROR' | 'APP_ERROR' | 'INVALID_MODULE' | 'SUBMODULE_NOT_DEFINED' | 'DISPATCH' | 'I18N' | (string & {});
+export interface ComponentDefaultProps<Ref = unknown> {
+    $silent?: boolean;
+    /**
+     * for React Component only
+     */
+    $ref?: RefObject<Ref>;
+    [k: string]: any;
+}
+export interface VariousError extends Error {
+    type: ErrorType;
+    originalError: Error;
+    module: ModuleDef;
+}
+interface ActionDef {
+    payload: any;
+    result: any;
+}
+interface MessageDef {
+    payload: any;
+}
+export type PublicAction<A extends ActionDef = never> = (params: {
+    payload: [A] extends [never] ? any : A['payload'];
+    trigger: ModuleDef;
+}) => [A] extends [never] ? any : A['result'];
+export type PublicActionDef = Record<string, ActionDef>;
+export type MessagesDef = Record<string, MessageDef>;
+export type DefineActions<T extends PublicActionDef> = T;
+export type DefineMessages<T extends MessagesDef> = T;
+interface Message<T extends MessagesDef = never> {
+    event: [T] extends [never] ? string : keyof T;
+    payload: [T] extends [never] ? any : T[keyof T]['payload'];
+    trigger: ModuleDef;
+}
+export { Message };
+export type StaticMethods<T extends PublicActionDef = never> = [
+    T
+] extends [never] ? Record<string, (params: {
+    payload: any;
+    trigger: ModuleDef;
+}) => any> : {
+    [K in keyof T]: T[K] extends {
+        payload: infer V;
+        result: infer R;
+    } ? (params: {
+        payload?: V;
+        trigger: ModuleDef;
+    }) => R : never;
+};
+export type ComponentStatics<S extends PublicActionDef = never, T extends MessagesDef = never> = {
+    $i18n?: I18n;
+    $onMessage?: OnMessage<T>;
+} & StaticMethods<S>;
+export type ComponentPublicActionMap = {
+    [name: string]: PublicActionDef;
+};
+type $dispatch<M extends ComponentPublicActionMap = never> = [M] extends [never] ? {
+    (params: {
+        target: string;
+        action: string;
+        payload?: any;
+    }): Promise<any>;
+} : {
+    <T extends keyof M, A extends keyof M[T]>(params: {
+        target: T;
+        action: A;
+        payload?: NonNullable<M[T][A]>['payload'];
+    }): Promise<NonNullable<M[T][A]>['result']>;
+};
+export type DefineAppActions<T extends PublicActionDef = {}> = DefineActions<{
+    setLocale: {
+        payload: string;
+        result: string;
+    };
+    getLocale: {
+        payload: undefined;
+        result: string;
+    };
+    updateI18nConfig: {
+        payload: Partial<I18nConfig>;
+        result: string;
+    };
+} & T>;
+type $postMessage<T extends MessagesDef = never> = [T] extends [never] ? (params: {
+    event: string;
+    payload?: any;
+}) => void : <K extends keyof T>(params: {
+    event: K;
+    payload?: T[K]['payload'];
+}) => void;
+type $logger = {
+    info: (message: any, type?: string) => void;
+    warn: (message: any, type?: string) => void;
+    error: (message: any, type?: string) => void;
+};
+export type Intl = ((key: string, paramsOrDefaultText?: Record<string, string | number> | string, defaultText?: string) => string) & {
+    update: (config: Partial<I18nConfig>) => void;
+};
+interface ComponentBuiltinProps<Store extends object = ObjectRecord, Messages extends MessagesDef = never, Actions extends ComponentPublicActionMap = never> {
+    $store: Readonly<Store>;
+    $dispatch: $dispatch<Actions>;
+    $postMessage: $postMessage<Messages>;
+    $t: Intl;
+    $logger: $logger;
+    $self: {
+        url: string;
+        module: ModuleDef;
+    };
+    $locale: string;
+}
+export interface I18nConfig {
+    resources: Record<string, Record<string, string>>;
+}
+export type I18n = () => I18nConfig | Promise<I18nConfig>;
+export type GlobalI18n = {
+    defaultLocale?: string;
+    getResources?: () => I18nConfig | Promise<I18nConfig>;
+};
+export type OnMessage<T extends MessagesDef = never> = (message: Message<T>) => void;
+export type VariousProps<Props extends object = ObjectRecord, Store extends object = ObjectRecord, Messages extends MessagesDef = never, Actions extends ComponentPublicActionMap = never> = ComponentBuiltinProps<Store, Messages, Actions> & Props;
+export type VariousFC<Props extends object = ObjectRecord, Store extends object = ObjectRecord, SelfActions extends PublicActionDef = never, Messages extends MessagesDef = never, Actions extends ComponentPublicActionMap = never> = FC<VariousProps<Props, Store, Messages, Actions>> & ComponentStatics<SelfActions, Messages>;
+export interface ErrorFallbackProps<Store extends object = ObjectRecord> {
+    $reload: () => void;
+    $error: VariousError;
+    $store: Readonly<Store>;
+    $self: {
+        url: string;
+        module: ModuleDef;
+    };
+    $locale: string;
+}
+export type ErrorFallbackNode<Store extends object = ObjectRecord> = ComponentType<ErrorFallbackProps<Store>>;
+export interface FallbackProps<Store extends object = ObjectRecord> {
+    $store: Readonly<Store>;
+    $self: {
+        url: string;
+        module: ModuleDef;
+    };
+    $locale: string;
+}
+export type FallbackNode<Store extends object = ObjectRecord> = ComponentType<FallbackProps<Store>>;
+type Dispatch<T extends object = ObjectRecord> = (nycticorax: {
+    getStore: <K extends keyof T | undefined = undefined>(k?: K | undefined) => K extends keyof T ? T[K] : T;
+    emit: (next: Partial<T>) => void;
+}, payload: any, trigger: ModuleDef) => Promise<any>;
+interface MessageEventArgs {
+    trigger: ModuleDef;
+    event: string;
+    payload?: any;
+}
+type MessageEventRes = boolean | Omit<MessageEventArgs, 'trigger'>;
+interface DispatchEventArgs {
+    target: ModuleDef;
+    trigger: ModuleDef;
+    action: string;
+    payload?: any;
+}
+type DispatchEventRes = boolean | Omit<DispatchEventArgs, 'trigger'>;
+interface LoadEventArgs {
+    module: ModuleDef;
+    loadStart: number;
+    loadEnd: number;
+    beenLoaded: boolean;
+}
+type LogLevel = 'info' | 'warn' | 'error';
+interface LogArgs {
+    module: ModuleDef;
+    level: LogLevel;
+    type?: string;
+    message: any;
+}
+export type MessageEvent = (e: MessageEventArgs) => Promise<MessageEventRes> | MessageEventRes;
+export type DispatchEvent = (e: DispatchEventArgs) => Promise<DispatchEventRes> | DispatchEventRes;
+export type LoadEvent = (e: LoadEventArgs) => void;
+export type ErrorEvent = (e: VariousError) => void;
+export type LogEvent = (e: LogArgs) => boolean;
+export interface App<Store extends object = ObjectRecord> {
+    store?: Store;
+    ErrorFallback?: ErrorFallbackNode<Store>;
+    Fallback?: FallbackNode<Store>;
+    actions?: Record<string, Dispatch<Store>>;
+    Root: ComponentType;
+    middlewares?: {
+        onLoad?: LoadEvent;
+        onError?: ErrorEvent;
+        onMessage?: MessageEvent;
+        onDispatch?: DispatchEvent;
+        onLog?: LogEvent;
+    };
+    i18n?: GlobalI18n;
+}
+export interface Config {
+    dependencies: {
+        app: string;
+        '@variousjs/various'?: string;
+        react?: string;
+        'react-dom'?: string;
+        vue?: string;
+    } & Record<string, string>;
+    root?: string;
+    timeout?: number;
+    earlyParallelDependencies?: string[];
+}
+export type VariousComponentProps<Store extends object = ObjectRecord, Messages extends MessagesDef = never, Actions extends ComponentPublicActionMap = never> = PropType<ComponentBuiltinProps<Store, Messages, Actions>>;
+export type GetModuleInfo = (module: ModuleDef) => {
+    name: string;
+    entry?: string;
+};
+export type PreloadModules = (modules: ModuleDef[]) => Promise<void>;
+export type RemoveLoadedModules = (modules: ModuleDef[]) => void;
+export type DefineDependencies = (deps: Record<string, string>) => void;
+export type IsModuleLoaded = (module: ModuleDef) => boolean;
+export type OnComponentMounted = (module: ModuleDef | ModuleDef[], callback: () => void) => (() => void) | void;
+export type CreateDispatch = <M extends ComponentPublicActionMap = never>(module: ModuleDef) => $dispatch<M>;
+export type CreatePostMessage = <Messages extends MessagesDef = never>(module: ModuleDef) => $postMessage<Messages>;
+export type CreateLogger = (module: ModuleDef) => $logger;
+export type GetStore = <Store extends object = ObjectRecord>() => Store;
+export type CreateModule = <T = unknown>(params: {
+    url?: string;
+    module: ModuleDef;
+}, logError?: boolean) => Promise<T>;
+export type CreateComponent = <Props extends object = ObjectRecord, Ref = unknown, Store extends object = ObjectRecord>(config: {
+    url?: string;
+    type?: VariousComponentType;
+    module: ModuleDef;
+}, 
+/**
+* set store keys if component created before store initialization
+*/
+storeKeys?: (keyof Store)[]) => ComponentType<ComponentDefaultProps<Ref> & Props>;
+export type RenderComponent = <Props extends object = ObjectRecord>(params: {
+    module: ModuleDef;
+    url?: string;
+    type?: VariousComponentType;
+    props?: Props & ComponentDefaultProps;
+    target: Element | null;
+    renderNode?: (children: ReactNode) => ReactNode;
+    onMounted?: () => void;
+}) => Promise<() => Promise<void>>;
+export type DependencyType = string | object | Function;
+export type StandaloneComponentConfig<Store extends object = ObjectRecord> = {
+    module: ModuleDef;
+    url?: string;
+    type?: VariousComponentType;
+    dependencies?: Partial<Record<string, DependencyType>>;
+    /**
+    * set store keys if component created before store initialization
+    */
+    storeKeys?: (keyof Store)[];
+};
+export type StandaloneCreateComponent = <Props extends object = ObjectRecord, Ref = unknown, Store extends object = ObjectRecord>(config: StandaloneComponentConfig<Store>) => ComponentType<Props & {
+    /**
+     * for React Component only
+     */
+    $ref?: RefObject<Ref>;
+}>;
+export type AppConfig<Store extends object = ObjectRecord> = Pick<App<Store>, 'actions' | 'store' | 'Fallback' | 'ErrorFallback' | 'i18n'> & {
+    dependencies: Partial<Record<string, DependencyType>>;
+};
+export type CreateAppConfig = <Store extends object = ObjectRecord>(config: AppConfig<Store>) => void;

package/dist/types/standalone/helper.d.ts

@@ -0,0 +1,3 @@
+import type { StandaloneComponentConfig, CreateAppConfig } from '../public/types';
+export declare function defineModules(deps: NonNullable<StandaloneComponentConfig['dependencies']>): Promise<void[]>;
+export declare const createAppConfig: CreateAppConfig;

package/dist/types/standalone/index.d.ts

@@ -0,0 +1,4 @@
+import type { StandaloneCreateComponent } from '../public/types';
+export { createAppConfig } from './helper';
+export { createDispatch, createLogger, createPostMessage } from '../core';
+export declare const createComponent: StandaloneCreateComponent;

package/dist/types/types.d.ts

@@ -0,0 +1,50 @@
+import React, { ComponentType, ReactNode } from 'react';
+import ReactDOM from 'react-dom/client';
+import type { Dispatch } from 'nycticorax';
+import type { VariousProps, PublicAction, Config, OnMessage, I18n, ModuleDef, App, I18nConfig } from './public/types';
+import { MESSAGE_KEY, DEPENDENCIES_KEY, MOUNTED_COMPONENTS_KEY, CONFIG_KEY, STANDALONE_CONFIG_READY, LOCALE_KEY } from './core/config';
+export { MESSAGE_KEY, DEPENDENCIES_KEY, MOUNTED_COMPONENTS_KEY, CONFIG_KEY, STANDALONE_CONFIG_READY, LOCALE_KEY, };
+export interface Store {
+    [MESSAGE_KEY]: null | (Parameters<OnMessage>[0] & {
+        timestamp: number;
+    });
+    [MOUNTED_COMPONENTS_KEY]: ModuleDef[];
+    [CONFIG_KEY]: Record<string | symbol, any>;
+    [DEPENDENCIES_KEY]: Record<string, string>;
+    [STANDALONE_CONFIG_READY]?: boolean;
+    [LOCALE_KEY]: string;
+    [key: string]: any;
+}
+export type Actions<S extends object> = Record<string, Dispatch<S>>;
+export type PublicActions = Record<string, PublicAction>;
+export type RequiredComponent = ComponentType<VariousProps> & Actions<Store> & PublicActions & {
+    $onMessage: OnMessage;
+    $i18n: I18n;
+} & {
+    [key: string]: RequiredComponent;
+};
+export interface CreateComponentState {
+    isError: boolean;
+    componentReady: boolean;
+}
+export interface CreateComponentProps<P extends object> extends Store {
+    $componentProps: P;
+}
+export type ErrorBoundaryProps = {
+    module: ModuleDef;
+    url?: string;
+    children: ReactNode;
+};
+export interface ConnectorI18nConfig extends I18nConfig {
+    loading?: boolean;
+}
+export interface Various {
+    getApp: (config: Config & App) => ComponentType;
+}
+export type AppWithDefault = {
+    default: App;
+};
+export type ReactType = typeof React;
+export type ReactDOMType = typeof ReactDOM & {
+    version: string;
+};

package/package.json

@@ -1,27 +1,25 @@
 {
   "name": "@variousjs/various",
-  "version": "6.0.0",
+  "version": "6.1.0",
   "type": "module",
-  "description": "ESM micro-frontend framework",
+  "description": "React-based ESM micro-frontend framework",
   "files": [
-    "dist",
-    "index.d.ts",
-    "standalone.d.ts"
+    "dist"
   ],
   "exports": {
     ".": {
       "import": {
-        "types": "./index.d.ts",
+        "types": "./dist/types/public/index.d.ts",
         "default": "./dist/index.js"
       }
     },
     "./standalone": {
       "import": {
-        "types": "./standalone.d.ts",
+        "types": "./dist/types/public/standalone.d.ts",
         "default": "./dist/standalone.mjs"
       },
       "require": {
-        "types": "./standalone.d.ts",
+        "types": "./dist/types/public/standalone.d.ts",
         "default": "./dist/standalone.js"
       }
     }
@@ -57,9 +55,11 @@
     "build:standalone": "TARGET=standalone vite build --mode development",
     "build:standalone:esm": "TARGET=standalone-esm vite build --mode development",
     "build:components": "TARGET=components vite build",
-    "build": "npm run build:core && npm run build:core:dev && npm run build:loader && npm run build:loader:dev && npm run build:standalone && npm run build:standalone:esm && npm run build:components",
+    "build:types": "tsc -p tsconfig.types.json",
+    "check:types": "vue-tsc -p tsconfig.consumer-check.json",
+    "build": "npm run build:core && npm run build:core:dev && npm run build:loader && npm run build:loader:dev && npm run build:standalone && npm run build:standalone:esm && npm run build:components && npm run build:types",
     "prebuild": "npm run lint && rm -rf dist && rm -rf public/dist && mkdir -p public/dist",
-    "postbuild": "npm run create-empty",
+    "postbuild": "npm run create-empty && npm run check:types",
     "prepublishOnly": "npm run build",
     "cy:run": "rm -rf .nyc_output coverage && cypress run",
     "ci": "start-server-and-test start:ci http://127.0.0.1:2333 cy:run",
@@ -104,7 +104,8 @@
     "typescript": "^5.9.3",
     "vite": "^8.1.5",
     "vite-plugin-istanbul": "^9.0.1",
-    "vue": "^3.5.40"
+    "vue": "^3.5.40",
+    "vue-tsc": "^3.3.11"
   },
   "dependencies": {
     "nycticorax": "^4.2.1"