@wexample/js-app 0.0.3 → 0.0.12

package/.wex/config.yml

@@ -1,3 +1,3 @@
 global:
   name: js_app
-  version: 0.0.3
+  version: 0.0.12

package/.wex/python/app_manager/app_workdir.py

@@ -9,12 +9,13 @@ class AppWorkdir(JavascriptPackageWorkdir):
         from wexample_helpers.helpers.string import string_to_kebab_case
 
         raw_value = super().prepare_value(raw_value=raw_value)
+        name_config = self.get_runtime_config().search("global.name")
 
         def _build_remote_github(target: AppWorkdir) -> str:
-            return f"git@github.com:wexample/{string_to_kebab_case(target.get_project_name())}.git"
+            return f"git@github.com:wexample/{string_to_kebab_case(name_config.get_str())}.git"
 
         def _build_remote_gitlab(target: AppWorkdir) -> str:
-            return f"ssh://git@gitlab.wexample.com:4567/wexample-javascript/{string_to_kebab_case(target.get_project_name())}.git"
+            return f"ssh://git@gitlab.wexample.com:4567/wexample-javascript/{string_to_kebab_case(name_config.get_str())}.git"
 
         raw_value["git"] = {
             "main_branch": "main",

package/.wex/python/app_manager/pyproject.toml

@@ -4,8 +4,6 @@ version = "0.0.1"
 description = "App manager entrypoint"
 requires-python = ">=3.10"
 dependencies = [
-    "jinja2",
-    "wexample-wex-addon-app==0.0.53",
     "wexample-wex-addon-dev-javascript==0.0.55",
 ]
 

package/README.md

@@ -1,6 +1,6 @@
-# js_app
+# @wexample/js-app
 
-Version: 0.0.3
+Version: 0.0.12
 
 ## Table of Contents
 
@@ -111,7 +111,7 @@ Free to use in both personal and commercial projects.
 
 ## Integration in the Suite
 
-This package is part of the **Wexample Suite** — a collection of high-quality Python packages designed to work seamlessly together.
+This package is part of the Wexample Suite — a collection of high-quality, modular tools designed to work seamlessly together across multiple languages and environments.
 
 ### Related Packages
 

package/package.json

@@ -1,8 +1,11 @@
 {
-  "version": "0.0.3",
+  "version": "0.0.12",
   "type": "module",
   "name": "@wexample/js-app",
   "publishConfig": {
     "access": "public"
+  },
+  "peerDependencies": {
+    "@wexample/js-helpers": "*"
   }
 }

package/src/Common/App.ts

@@ -0,0 +1,115 @@
+import MixinsService from '@wexample/js-app/Services/MixinsService';
+import AsyncConstructor from '@wexample/js-helpers/Common/AsyncConstructor';
+import { arrayUnique } from '@wexample/js-helpers/Helper/Array';
+import type ServicesRegistryInterface from '../Interfaces/ServicesRegistryInterface';
+import type { AppServiceConstructor, ServiceDefinition } from '../Types/AppServiceTypes';
+import type AppService from './AppService';
+
+type ReadyCallback = (() => void) | (() => Promise<void>);
+
+export default class App extends AsyncConstructor {
+  public services: ServicesRegistryInterface = {};
+
+  constructor(readyCallback?: ReadyCallback, globalName: string = 'app') {
+    super();
+
+    window[globalName] = this;
+
+    const doc = window.document;
+
+    const run = async () => {
+      // Allow children to perform setup before sealing.
+      await this.beforeReady();
+
+      // Every core properties has been set,
+      // block any try to add extra property.
+      this.seal();
+
+      // Execute ready callbacks.
+      await this.readyComplete();
+
+      readyCallback && (await readyCallback());
+    };
+
+    const readyState = doc.readyState;
+
+    // Document has been parsed.
+    // Allows running after loaded event.
+    if (['complete', 'loaded', 'interactive'].indexOf(readyState) !== -1) {
+      this.defer(run);
+    } else {
+      doc.addEventListener('DOMContentLoaded', run);
+    }
+  }
+
+  // Hook for children: executed after DOM is ready but before seal().
+  protected async beforeReady(): Promise<void> {
+    await this.loadAndInitServices(this.getServices());
+  }
+
+  getServices(): ServiceDefinition[] {
+    return [MixinsService];
+  }
+
+  loadServices(services: ServiceDefinition[]): AppService[] {
+    services = this.getServicesAndDependencies(services);
+    const instances = [];
+
+    services.forEach((service: ServiceDefinition) => {
+      let serviceClass: AppServiceConstructor;
+      let serviceArgs: unknown[] = [];
+
+      if (Array.isArray(service)) {
+        serviceClass = service[0];
+        serviceArgs = service[1];
+      } else {
+        serviceClass = service;
+      }
+
+      const name = serviceClass.serviceName;
+
+      if (!this.services[name]) {
+        this.services[name] = new serviceClass(this, ...serviceArgs);
+        instances.push(this.services[name]);
+      }
+    });
+
+    return instances;
+  }
+
+  async loadAndInitServices(services: ServiceDefinition[]): Promise<unknown> {
+    const loadedServices = this.loadServices(services);
+
+    return this.services.mixins.invokeUntilComplete(
+      'hookInit',
+      'app',
+      [],
+      undefined,
+      loadedServices
+    );
+  }
+
+  getServicesAndDependencies(services: ServiceDefinition[]): ServiceDefinition[] {
+    services.forEach((serviceDef: ServiceDefinition) => {
+      let serviceClass: AppServiceConstructor;
+
+      if (Array.isArray(serviceDef)) {
+        serviceClass = serviceDef[0];
+      } else {
+        serviceClass = serviceDef;
+      }
+
+      if (serviceClass.dependencies) {
+        services = [...services, ...this.getServicesAndDependencies(serviceClass.dependencies)];
+      }
+    });
+
+    return arrayUnique(services) as ServiceDefinition[];
+  }
+
+  getService(name: string | { serviceName: string }): AppService {
+    name = typeof name === 'string' ? name : name.serviceName;
+
+    return this.services[name];
+  }
+}

package/src/Common/AppChild.ts

@@ -0,0 +1,10 @@
+import AsyncConstructor from '@wexample/js-helpers/Common/AsyncConstructor';
+import type App from './App';
+
+export default class extends AsyncConstructor {
+  constructor(protected readonly app: App) {
+    super();
+
+    this.app = app;
+  }
+}

package/src/Common/AppService.ts

@@ -0,0 +1,24 @@
+import type { ServiceDefinition } from '../Types/AppServiceTypes';
+import type App from './App';
+import AppChild from './AppChild';
+
+export default abstract class AppService extends AppChild {
+  public static LOAD_STATUS_COMPLETE = 'complete';
+  public static LOAD_STATUS_WAIT = 'wait';
+
+  public app: App;
+  public static dependencies: ServiceDefinition[] = [];
+  public static serviceName: string;
+
+  registerHooks(): {
+    app?: Record<string, unknown>;
+    page?: Record<string, unknown>;
+    renderNode?: Record<string, unknown>;
+  } {
+    return {};
+  }
+
+  registerMethods(_object: unknown, _group: string) {
+    return {};
+  }
+}

package/src/Interfaces/ServicesRegistryInterface.ts

@@ -0,0 +1,5 @@
+import type MixinsService from '../Services/MixinsService';
+
+export default interface ServicesRegistryInterface {
+  mixins?: MixinsService;
+}

package/src/Services/MixinsService.ts

@@ -0,0 +1,87 @@
+import AppService from '@wexample/js-app/Common/AppService';
+import type { AppServiceConstructor } from '../Types/AppServiceTypes';
+
+export default class MixinsService extends AppService {
+  public static serviceName = 'mixins';
+
+  /**
+   * Execute a hook until all ext do not return false.
+   * Useful to manage order when processing : an ext can wait for
+   * another one to be executed.
+   *
+   * The pre-last arg of callback will be a registry of ext statuses.
+   * The last arg of callback well be a next() method in case of async operation.
+   *
+   * @param method
+   * @param args
+   * @param group
+   * @param timeoutLimit
+   * @param services
+   */
+  async invokeUntilComplete(
+    method: string,
+    group: string = 'app',
+    args: unknown[] = [],
+    timeoutLimit: number = 2000,
+    services: AppService[] = Object.values(this.app.services) as AppService[]
+  ): Promise<boolean> {
+    const errorTrace: AppService[] = [];
+    let loops: number = 0;
+    const loopsLimit: number = 100;
+    const registry: Record<string, unknown> = {};
+
+    while (true) {
+      const service = services.shift();
+      if (!service) {
+        break;
+      }
+
+      const currentName = (service.constructor as AppServiceConstructor).serviceName;
+      const timeout = setTimeout(() => {
+        const message = [
+          `Mixins invocation timeout on method "${method}", stopping at "${currentName}".`,
+          `Registry: ${JSON.stringify(registry)}.`,
+        ].join(' ');
+
+        throw new Error(message);
+      }, timeoutLimit);
+
+      const hooks = service.registerHooks() as Record<string, Record<string, unknown>> | undefined;
+      const hook = hooks?.[group]?.[method];
+
+      if (loops++ > loopsLimit) {
+        const message = [
+          `Stopping more than ${loops} recursions during services invocation on method "${method}", stopping at ${currentName}.`,
+          `Trace: ${errorTrace.join(' -> ') || 'none'}.`,
+          `Registry: ${JSON.stringify(registry)}.`,
+        ].join(' ');
+
+        throw new Error(message);
+      } else if (loops > loopsLimit - 10) {
+        errorTrace.push(service);
+      }
+
+      if (typeof hook === 'function') {
+        const argsLocal = args.concat([registry]);
+        registry[currentName] = await (hook as (...hookArgs: unknown[]) => unknown).apply(
+          service,
+          argsLocal
+        );
+      }
+
+      if (registry[currentName] === undefined) {
+        registry[currentName] = AppService.LOAD_STATUS_COMPLETE;
+      }
+
+      // "wait" says to retry after processing other services.
+      if (registry[currentName] === AppService.LOAD_STATUS_WAIT) {
+        // Enqueue again.
+        services.push(service);
+      }
+
+      clearTimeout(timeout);
+    }
+
+    return true;
+  }
+}

package/src/Types/AppServiceTypes.ts

@@ -0,0 +1,12 @@
+import type App from '../Common/App';
+import type AppService from '../Common/AppService';
+
+export type AppServiceConstructor = (new (
+  app: App,
+  ...args: unknown[]
+) => AppService) & {
+  serviceName: string;
+  dependencies?: ServiceDefinition[];
+};
+
+export type ServiceDefinition = AppServiceConstructor | [AppServiceConstructor, unknown[]];

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "strict": false,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": false,
+    "declarationMap": false,
+    "isolatedModules": true,
+    "resolveJsonModule": true,
+    "baseUrl": ".",
+    "paths": {
+      "@wexample/js-app": ["./src"],
+      "@wexample/js-app/*": ["./src/*"],
+      "@wexample/js-helpers": ["../js-helpers/src"],
+      "@wexample/js-helpers/*": ["../js-helpers/src/*"],
+      "@wexample/js-pseudocode": ["../js-pseudocode/src"],
+      "@wexample/js-pseudocode/*": ["../js-pseudocode/src/*"]
+    }
+  },
+  "include": ["src"],
+  "exclude": ["dist", "node_modules"]
+}

package/version.txt

@@ -1 +1 @@
-0.0.3
+0.0.12