apprun 3.36.1 → 3.37.0

package/src/types.ts

@@ -59,10 +59,10 @@ export type VDOM = false | string | VNode | Array<VNode | string> | TemplateResu
 export type View<T> = (state: T) => VDOM | void;
 export type Action<T> = (state: T, ...p: any[]) => T | Promise<T> | void;
 export type ActionDef<T, E> = (readonly [E, Action<T>, {}?]);
-export type Update<T, E = string> = ActionDef<T, E>[] | { [name: string]: Action<T> | {}[] } | (E | Action<T> | {})[];
+export type Update<T, E = any> = ActionDef<T, E>[] | { [name: string]: Action<T> | {}[] } | (E | Action<T> | {})[];
 export type ActionOptions = {
   render?: boolean, history?, global?: boolean;
-  callback?: (state) => void;
+  callback?: (state: any) => void;
 };
 export type EventOptions = {
   once?: boolean;
@@ -82,3 +82,63 @@ export type AppStartOptions<T> = {
   rendered?: (state: T) => void
   mounted?: (props: any, children: any, state: T) => T
 };
+export type Router = (url: string, ...args: any[]) => any;
+
+export type CustomElementOptions = {
+  render?: boolean;
+  shadow?: boolean;
+  history?: boolean;
+  global_event?: boolean;
+  observedAttributes?: string[];
+};
+
+export interface IApp {
+  // Event system methods
+  on(name: string, fn: (...args: any[]) => any, options?: EventOptions): void;
+  off(name: string, fn: (...args: any[]) => any): void;
+  run(name: string, ...args: any[]): number;
+  runAsync(name: string, ...args: any[]): Promise<any[]>;
+  once(name: string, fn: (...args: any[]) => any, options?: EventOptions): void;
+  find(name: string): any;
+
+  /** @deprecated Use runAsync() instead */
+  query(name: string, ...args: any[]): Promise<any[]>;
+
+  start<T, E = any>(element?: Element | string, model?: T, view?: View<T>, update?: Update<T, E>,
+    options?: AppStartOptions<T>): any;
+
+  h(tag: string | Function, props?: any, ...children: any[]): VNode | VNode[];
+  createElement(tag: string | Function, props?: any, ...children: any[]): VNode | VNode[];
+  render(element: Element | ShadowRoot, node: VNode, component?: {}): void;
+  Fragment(props: any, ...children: any[]): any[];
+  route: Router;
+  webComponent(name: string, componentClass: any, options?: CustomElementOptions): void;
+  safeHTML(html: string): any[];
+  use_render(render: any, mode?: 0 | 1): void;
+  use_react(React: any, ReactDOM: any): void;
+  version: string;
+  basePath?: string;
+  addComponents: (element: Element | string, components: ComponentRoute) => void;
+}
+
+// Define what constitutes a mountable component
+interface ComponentLike {
+  mount(element?: Element | string, options?: any): any;
+}
+
+// Define component constructor type
+type ComponentConstructor<T = any> = new (
+  state?: T,
+  view?: any,
+  update?: any,
+  options?: any
+) => ComponentLike;
+
+// Enhanced ComponentRoute type with clear distinctions
+export type ComponentRoute = {
+  [route: string]:
+  | ComponentLike                                    // Component instance
+  | ComponentConstructor                             // Component class constructor
+  | (() => ComponentLike | ComponentConstructor | Promise<ComponentLike | ComponentConstructor>) // Factory function
+  | ((...args: any[]) => any)                       // Event handler function
+};

package/src/version.ts

@@ -10,7 +10,7 @@
 
 // Import version from package.json to maintain single source of truth
 // This version string is used across the framework
-export const APPRUN_VERSION = '3.36.1';
+export const APPRUN_VERSION = '3.37.0';
 
 // Version string with prefix for global tracking
 export const APPRUN_VERSION_GLOBAL = `AppRun-${APPRUN_VERSION}`;

package/src/web-component.ts

@@ -53,18 +53,12 @@
 
 declare var customElements;
 
-export type CustomElementOptions = {
-  render?: boolean;
-  shadow?: boolean;
-  history?: boolean;
-  global_event?: boolean;
-  observedAttributes?: string[];
-};
+import { CustomElementOptions } from './types';
 
 export const customElement = (componentClass, options: CustomElementOptions = {}) => class CustomElement extends HTMLElement {
-  private _shadowRoot;
-  private _component;
-  private _attrMap: (arg0: string) => string;
+  public _shadowRoot;
+  public _component;
+  public _attrMap: (arg0: string) => string;
   public on;
   public run;
   constructor() {

package/tsconfig.jest.json

@@ -1,17 +1,21 @@
 {
 	"compilerOptions": {
-		"target": "es2015",
-		"module": "es2015",
+		"target": "es2020",
+		"module": "esnext",
 		"moduleResolution": "node",
 		"jsx": "react",
 		"reactNamespace": "app",
-		"lib": ["dom", "esnext"],
+		"lib": [
+			"dom",
+			"esnext"
+		],
 		"experimentalDecorators": true,
 		"sourceMap": true,
 		"esModuleInterop": true,
 		"downlevelIteration": true,
 		"allowJs": true,
 		"outDir": "coverage/src",
+		"isolatedModules": true,
 		"strict": true,
 		"noImplicitAny": true,
 		"strictNullChecks": true,
@@ -24,17 +28,22 @@
 		"forceConsistentCasingInFileNames": true,
 		"baseUrl": ".",
 		"paths": {
-			"*": ["src/types/*"]
+			"*": [
+				"src/types/*"
+			]
 		},
 		"typeRoots": [
 			"./node_modules/@types",
 			"./src/types"
 		],
-		"types": ["jest", "node"]
+		"types": [
+			"jest",
+			"node"
+		]
 	},
 	"include": [
 		"src/**/*",
 		"tests/**/*",
 		"demo/**/*"
 	]
-}
+}

package/tsconfig.json

@@ -1,12 +1,12 @@
 {
 	"compilerOptions": {
-		"target": "es2018",
-		"module": "es2015",
+		"target": "es2020",
+		"module": "esnext",
 		"moduleResolution": "node",
 		"jsx": "react",
 		"jsxFactory": "app.h",
 		"jsxFragmentFactory": "app.Fragment",
-		"lib": ["dom", "es2018", "esnext.asynciterable"],
+		"lib": ["dom", "es2020", "esnext.asynciterable"],
 		"experimentalDecorators": true,
 		"sourceMap": true,
 		"esModuleInterop": true,

package/webpack.config.cjs

@@ -5,9 +5,11 @@ module.exports = {
   entry: {
     'dist/apprun': './src/apprun.ts',
     'dist/apprun-play': './src/apprun-play.tsx',
+    'dist/apprun-code': './src/apprun-code.tsx',
     'dist/apprun-html': './src/apprun-html.ts',
-    './jsx-runtime': './src/vdom.ts',
     'dist/apprun-dev-tools': './src/apprun-dev-tools.tsx',
+    'dist/createState': './src/createState.ts',
+    'jsx-runtime': './src/vdom.ts',
     'demo/app': './demo/main.ts'
   },
   output: {

package/src/types/apprun.d.ts

@@ -1,56 +0,0 @@
-declare type VNode = {
-  tag: string;
-  props?: Record<string, any>;
-  children?: Array<VNode | string | number>;
-} | string | number;
-
-declare type VDOM = VNode | VNode[];
-
-declare type View<T = any> = (state: T) => VDOM | void;
-declare type Action<T = any> = (state: T, ...p: any[]) => T | void | Promise<T>;
-declare type ActionDef<T = any> = [Action<T>, object?];
-declare type Update<T = any> = { [name: string]: Action<T> | ActionDef<T> | Array<Action<T> | ActionDef<T>> };
-
-declare interface IApp {
-  start<T>(element?: Element | string | null, model?: T, view?: View<T>, update?: Update<T>, options?: AppStartOptions): Component<T>;
-  on(name: string, fn: (...args: any[]) => void, options?: any): void;
-  run(name: string, ...args: any[]): void;
-  createElement(tag: string | Function, props?: any, ...children: any[]): VNode;
-  render(element: Element, node: VNode): void;
-}
-
-declare interface Component<T = any> {
-  readonly state: T;
-  setState(state: T, options?: any): void;
-  mount(element?: Element | string | null, options?: any): Component<T>;
-  start(element?: Element | string | null, options?: any): Component<T>;
-  run(name: string, ...args: any[]): void;
-  rendered?: (state: T) => void;
-  view?: View<T>;
-  update?: Update<T>;
-  element?: Element;
-}
-
-declare interface CustomElementOptions {
-  render?: boolean;
-  shadow?: boolean;
-  history?: boolean | { prev: string; next: string };
-  global_event?: boolean;
-  route?: string;
-}
-
-declare interface AppStartOptions extends CustomElementOptions {
-  render?: boolean;
-  history?: boolean | { prev: string; next: string };
-  global_event?: boolean;
-  route?: string;
-}
-
-declare interface Route {
-  (url: string): void;
-  push(url: string, notify?: boolean): void;
-}
-
-declare const app: IApp;
-declare function on<T = any>(name?: string, options?: any): (target: any, key: string) => void;
-declare function Component<T = any>(options?: any): (constructor: Function) => void;