@rpgjs/common 4.3.0 → 5.0.0-alpha.0

package/src/Utils.ts

@@ -1,208 +1,269 @@
-import { constructor } from "@rpgjs/types";
+export type Constructor<T = {}> = new (...args: any[]) => T;
 
 export function random(min: number, max: number): number {
-    return Math.floor(Math.random() * (max - min + 1) + min)
+  return Math.floor(Math.random() * (max - min + 1) + min);
 }
 
 export function isBrowser(): boolean {
-    return typeof window !== 'undefined'
+  return typeof window !== "undefined";
 }
 
 export function isFunction(val: unknown): boolean {
-    return {}.toString.call(val) === '[object Function]'
+  return {}.toString.call(val) === "[object Function]";
 }
 
 export function isClass(func: unknown): boolean {
-    return typeof func === 'function';
+  return typeof func === "function";
 }
 
 export function isPromise(val: unknown) {
-    return isInstanceOf<Promise<unknown>>(val, Promise)
+  return isInstanceOf<Promise<unknown>>(val, Promise);
 }
 
 export function isArray(val: unknown) {
-    return isInstanceOf<Array<unknown>>(val, Array)
+  return isInstanceOf<Array<unknown>>(val, Array);
 }
 
 export function isObject(val: unknown): boolean {
-    return typeof val == 'object' && val != null && !isArray(val)
+  return typeof val == "object" && val != null && !isArray(val);
 }
 
 export function isString(val: unknown): boolean {
-    return typeof val == 'string'
+  return typeof val == "string";
 }
 
 export function isInstanceOf<T = any>(val: unknown, _class: any) {
-    return val instanceof _class
+  return val instanceof _class;
 }
 
 export function arrayUniq(array: any[]): any[] {
-    return [...new Set(array)]
+  return [...new Set(array)];
 }
 
 export function arrayFlat(array: any[]): any[] {
-    return array.reduce((acc, val) => acc.concat(val), [])
+  return array.reduce((acc, val) => acc.concat(val), []);
 }
 
-export function intersection([start1, end1]: [number, number], [start2, end2]: [number, number]): boolean {
-    return (start1 >= start2 && start1 <= end2) || (start2 >= start1 && start2 < end1)
+export function intersection(
+  [start1, end1]: [number, number],
+  [start2, end2]: [number, number]
+): boolean {
+  return (
+    (start1 >= start2 && start1 <= end2) || (start2 >= start1 && start2 < end1)
+  );
 }
 
 export function capitalize(s: unknown): string {
-    if (typeof s !== 'string') return ''
-    return s.charAt(0).toUpperCase() + s.slice(1)
+  if (typeof s !== "string") return "";
+  return s.charAt(0).toUpperCase() + s.slice(1);
 }
 
 export function camelToKebab(str: string): string {
-    return str
-        .replace(/([a-z])([A-Z])/g, '$1-$2')
-        .toLowerCase();
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
 }
 
 export function arrayEquals(a: any[], b: any[]): boolean {
-    return a.length === b.length && a.every((v, i) => v === b[i])
+  return a.length === b.length && a.every((v, i) => v === b[i]);
 }
 
-export function applyMixins(derivedCtor: constructor<any>, baseCtors: constructor<any>[]) {
-    baseCtors.forEach((baseCtor) => {
-        Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {
-            const baseCtorName = Object.getOwnPropertyDescriptor(baseCtor.prototype, name)
-            if (!baseCtorName) {
-                return
-            }
-            Object.defineProperty(derivedCtor.prototype, name, baseCtorName)
-        })
-    })
+/**
+ * Combines multiple mixins into one
+ *
+ * @param mixins - Array of mixin functions to combine
+ * @returns A single mixin function that applies all mixins
+ *
+ * @example
+ * ```ts
+ * const AllMixins = combineMixins([WithStats, WithInventory, WithComponentManager]);
+ * class MyClass extends AllMixins(BaseClass) {
+ *   // MyClass now has all capabilities from all mixins
+ * }
+ * ```
+ */
+export function combineMixins(
+  mixins: Array<<T extends Constructor>(Base: T) => any>
+) {
+  return <T extends Constructor>(Base: T) =>
+    mixins.reduce((ExtendedClass, mixin) => mixin(ExtendedClass), Base);
+}
+
+export function applyMixins(derivedCtor: any, baseCtors: any[]) {
+  baseCtors.forEach((baseCtor) => {
+    Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {
+      const baseCtorName = Object.getOwnPropertyDescriptor(
+        baseCtor.prototype,
+        name
+      );
+      if (!baseCtorName) {
+        return;
+      }
+      Object.defineProperty(derivedCtor.prototype, name, baseCtorName);
+    });
+  });
 }
 
 export function generateUID(): string {
-    let firstPart: any = (Math.random() * 46656) | 0
-    let secondPart: any = (Math.random() * 46656) | 0
-    firstPart = ("000" + firstPart.toString(36)).slice(-3)
-    secondPart = ("000" + secondPart.toString(36)).slice(-3)
-    return firstPart + secondPart
+  let firstPart: any = (Math.random() * 46656) | 0;
+  let secondPart: any = (Math.random() * 46656) | 0;
+  firstPart = ("000" + firstPart.toString(36)).slice(-3);
+  secondPart = ("000" + secondPart.toString(36)).slice(-3);
+  return firstPart + secondPart;
 }
 
 export function createConstructor<T>(...propNames: any[]): T {
-    return class {
-        constructor(...propValues) {
-            propNames.forEach((name, idx) => {
-                this[name] = propValues[idx]
-            })
-        }
-    } as unknown as T
+  return class {
+    constructor(...propValues) {
+      propNames.forEach((name, idx) => {
+        this[name] = propValues[idx];
+      });
+    }
+  } as unknown as T;
 }
 
 export function sharedArrayBuffer() {
-    let buffer
-    if (typeof SharedArrayBuffer != 'undefined') {
-        buffer = SharedArrayBuffer
-    }
-    else {
-        buffer = ArrayBuffer
-    }
-    return buffer
+  let buffer;
+  if (typeof SharedArrayBuffer != "undefined") {
+    buffer = SharedArrayBuffer;
+  } else {
+    buffer = ArrayBuffer;
+  }
+  return buffer;
 }
 
 export function toRadians(angle: number) {
-    return angle * (Math.PI / 180)
+  return angle * (Math.PI / 180);
 }
 
 export function hexaToNumber(hexa: string): {
-    value: number,
-    alpha: number
+  value: number;
+  alpha: number;
 } {
-    let val = hexa.replace('#', '')
-    let alpha = 1
-    if (val.length === 3) {
-        val = val.split('').map((v) => v + v).join('')
-    }
-    if (val.length === 8) {
-        alpha = parseInt(val.substring(0, 2), 16) / 255
-        val = val.substring(2)
-    }
-    return {
-        value: parseInt(val, 16),
-        alpha
-    }
+  let val = hexa.replace("#", "");
+  let alpha = 1;
+  if (val.length === 3) {
+    val = val
+      .split("")
+      .map((v) => v + v)
+      .join("");
+  }
+  if (val.length === 8) {
+    alpha = parseInt(val.substring(0, 2), 16) / 255;
+    val = val.substring(2);
+  }
+  return {
+    value: parseInt(val, 16),
+    alpha,
+  };
 }
 
 export function extractId(path: string): string | null {
-    const id = path.match(/([a-zA-Z0-9-_$!]+)\.[a-z0-9]+$/i)
-    if (!id) return null
-    return id[1]
+  const id = path.match(/([a-zA-Z0-9-_$!]+)\.[a-z0-9]+$/i);
+  if (!id) return null;
+  return id[1];
 }
 
 export function basename(path: string): string {
-    return path.substring(path.lastIndexOf('/') + 1)
+  return path.substring(path.lastIndexOf("/") + 1);
 }
 
 export function fps2ms(fps: number): number {
-    return 1000 / fps
+  return 1000 / fps;
 }
 
 export function preciseNow(): number {
-    return typeof performance !== 'undefined' ? performance.now() : Date.now()
+  return typeof performance !== "undefined" ? performance.now() : Date.now();
 }
 
 export function round(num: number, decimals: number = 100): number {
-    return Math.round(num * decimals) / decimals
+  return Math.round(num * decimals) / decimals;
 }
 
 // https://stackoverflow.com/questions/54733539/javascript-implementation-of-lodash-set-method
 export function set(obj, path, value, onlyPlainObject = false) {
-    if (Object(obj) !== obj) return obj; // When obj is not an object
-    // If not yet an array, get the keys from the string-path
-    if (!Array.isArray(path)) path = path.toString().match(/[^.[\]]+/g) || [];
-    path.slice(0, -1).reduce((a, c, i) => // Iterate all of them except the last one
-        Object(a[c]) === a[c] // Does the key exist and is its value an object?
-            // Yes: then follow that path
-            ? a[c]
-            // No: create the key. Is the next key a potential array-index?
-            : a[c] = Math.abs(path[i + 1]) >> 0 === +path[i + 1]
-                ? onlyPlainObject ? {} : [] // Yes: assign a new array object
-                : {}, // No: assign a new plain object
-        obj)[path[path.length - 1]] = value; // Finally assign the value to the last key
-    return obj; // Return the top-level object to allow chaining
-};
+  if (Object(obj) !== obj) return obj; // When obj is not an object
+  // If not yet an array, get the keys from the string-path
+  if (!Array.isArray(path)) path = path.toString().match(/[^.[\]]+/g) || [];
+  path.slice(0, -1).reduce(
+    (
+      a,
+      c,
+      i // Iterate all of them except the last one
+    ) =>
+      Object(a[c]) === a[c] // Does the key exist and is its value an object?
+        ? // Yes: then follow that path
+          a[c]
+        : // No: create the key. Is the next key a potential array-index?
+          (a[c] =
+            Math.abs(path[i + 1]) >> 0 === +path[i + 1]
+              ? onlyPlainObject
+                ? {}
+                : [] // Yes: assign a new array object
+              : {}), // No: assign a new plain object
+    obj
+  )[path[path.length - 1]] = value; // Finally assign the value to the last key
+  return obj; // Return the top-level object to allow chaining
+}
 
 export function elementToPositionAbsolute(element: HTMLElement) {
-    element.style.position = 'absolute'
-    element.style.top = '0'
-    element.style.left = '0'
-    element.style.right = '0'
-    element.style.bottom = '0'
-    element.style.width = '100%'
-    element.style.height = '100%'
+  element.style.position = "absolute";
+  element.style.top = "0";
+  element.style.left = "0";
+  element.style.right = "0";
+  element.style.bottom = "0";
+  element.style.width = "100%";
+  element.style.height = "100%";
+}
+
+
+export function mergeObjectWithMethods<T, S>(target: T, source: S): T & S {
+  // Copier toutes les propriétés propres (énumérables et non-énumérables)
+  const propertyNames = Object.getOwnPropertyNames(source);
+  for (const name of propertyNames) {
+      if (name !== 'constructor') {
+          const descriptor = Object.getOwnPropertyDescriptor(source, name);
+          if (descriptor) {
+              Object.defineProperty(target, name, descriptor);
+          }
+      }
+  }
+  
+  // Configurer le prototype pour hériter des méthodes de la classe
+  const sourceProto = Object.getPrototypeOf(source);
+  if (sourceProto && sourceProto !== Object.prototype) {
+      Object.setPrototypeOf(target, sourceProto);
+  }
+  
+  return target as T & S;
 }
 
 export default {
-    random,
-    isBrowser,
-    isPromise,
-    isArray,
-    isObject,
-    isString,
-    isFunction,
-    isClass,
-    isInstanceOf,
-    arrayUniq,
-    arrayFlat,
-    arrayEquals,
-    intersection,
-    applyMixins,
-    capitalize,
-    sharedArrayBuffer,
-    generateUID,
-    createConstructor,
-    toRadians,
-    extractId,
-    basename,
-    fps2ms,
-    preciseNow,
-    hexaToNumber,
-    set,
-    round,
-    camelToKebab,
-    elementToPositionAbsolute
-}
+  random,
+  isBrowser,
+  isPromise,
+  isArray,
+  isObject,
+  isString,
+  isFunction,
+  isClass,
+  isInstanceOf,
+  arrayUniq,
+  arrayFlat,
+  arrayEquals,
+  intersection,
+  applyMixins,
+  capitalize,
+  sharedArrayBuffer,
+  generateUID,
+  createConstructor,
+  toRadians,
+  extractId,
+  basename,
+  fps2ms,
+  preciseNow,
+  hexaToNumber,
+  set,
+  round,
+  camelToKebab,
+  elementToPositionAbsolute,
+  mergeObjectWithMethods
+};

package/src/database/Item.ts

@@ -0,0 +1,19 @@
+import { signal } from "@signe/reactive";
+import { id, sync } from "@signe/sync";
+import { RpgCommonPlayer } from "../Player";
+
+export class Item {
+    @id() id = signal('');
+    @sync() name = signal('');
+    @sync() description = signal('');
+    @sync() price = signal(0);
+    @sync() quantity = signal(1);
+
+    onAdd: (player: RpgCommonPlayer) => void = () => {};
+
+    constructor(data: any) {
+        this.description.set(data.description);
+        this.price.set(data.price);
+        this.onAdd = data.onAdd?.bind(this) ?? (() => {});
+    }
+}

package/src/database/index.ts

@@ -0,0 +1 @@
+export * from "./Item";

package/src/index.ts

@@ -1,25 +1,9 @@
-import AbstractObject from './Player';
-export { LiteralDirection, RpgCommonPlayer } from './Player'
-export { AbstractObject }
-export { RpgCommonEvent } from './Event'
-export { RpgCommonMap } from './Map'
-export { RpgCommonGame, GameSide } from './Game'
-export { EventEmitter } from './EventEmitter'
-export { PrebuiltGui } from './gui/PrebuiltGui'
-export  *as Utils from './Utils'
-export { RpgPlugin, type Plugin, HookServer, HookClient } from './Plugin'
-export * as TransportIo from './transports/io'
-export { Input, Control } from '@rpgjs/types'
-export { Hit } from './Hit'
-export { Scheduler } from './Scheduler'
-export { RpgModule, loadModules, type ModuleType } from './Module'
-export * as MockIo from './transports/io'
-export * as Logger from './Logger';
-export { RpgShape, ShapePositioning } from './Shape'
-export { VirtualGrid } from './VirtualGrid'
-export { RpgCommonWorldMaps } from './WorldMaps'
-export { Vector2d } from './Vector2d'
-export { Direction } from '@rpgjs/types'
-export { transitionColor } from './Color'
-export { DefaultInput } from './DefaultInput'
-export { type InjectInit, InjectContext } from './Inject'
+export * from "./Player";
+export * from "./rooms/Map";
+export * from "./modules";
+export * from "./services/updateMap";
+export * from "./Utils";
+export * from "./PrebuiltGui";
+export * from "./movement";
+export * as Matter from "matter-js";
+export * from "./database";

package/src/modules.ts

@@ -0,0 +1,230 @@
+export const ModulesToken = "ModulesToken";
+
+import { Context, Provider, Providers } from "@signe/di";
+import { Subject, Observable, from } from "rxjs";
+import { mergeMap, toArray } from "rxjs/operators";
+
+export class Hooks {
+  /**
+   * Store of all module hooks by ID
+   */
+  private moduleHooks: Record<string, Subject<any>> = {};
+
+  /**
+   * Store of all hook functions by ID
+   */
+  private hookFunctions: Record<string, Function[]> = {};
+
+  constructor(private modules: any[], private namespace: string) {
+    this.init();
+  }
+
+  private init() {
+    for (const module of this.modules) {
+      for (const type in module) {
+        const hookObject = module[type];
+        for (const hook in hookObject) {
+          const hookFunction = hookObject[hook];
+          if (hookFunction) {
+            const hookId = `${this.namespace}-${type}-${hook}`;
+
+            // Créer un Subject pour ce hook s'il n'existe pas déjà
+            if (!this.moduleHooks[hookId]) {
+              this.moduleHooks[hookId] = new Subject<any>();
+            }
+
+            // Initialiser le tableau de fonctions pour cet ID si nécessaire
+            if (!this.hookFunctions[hookId]) {
+              this.hookFunctions[hookId] = [];
+            }
+
+            // Ajouter la fonction au tableau des hooks pour cet ID
+            // (sans l'exécuter immédiatement)
+            if (!this.hookFunctions[hookId].includes(hookFunction)) {
+              this.hookFunctions[hookId].push(hookFunction);
+            }
+          }
+        }
+      }
+    }
+
+    return this.moduleHooks;
+  }
+
+  /**
+   * Call hooks for a specific ID, passing arguments to all subscribed hooks
+   *
+   * @param hookId - The unique identifier of the module hook
+   * @param args - Arguments to pass to the hook functions
+   * @returns An Observable that emits an array with all hook results when subscribed
+   * @example
+   * ```ts
+   * // Call all hook functions for the ID 'my-namespace-type-hook'
+   * callHooks('my-namespace-type-hook', { x: 10, y: 20 }).subscribe(results => {
+   *   console.log('Hook results:', results);  // Array of all hook function results
+   * });
+   * 
+   * // Hook functions are only executed when you subscribe to the returned Observable
+   * const observable = callHooks('my-namespace-type-hook', player);
+   * // ... later ...
+   * observable.subscribe(results => {
+   *   // Process results array
+   * });
+   * ```
+   */
+  public callHooks(hookId: string, ...args: any[]): Observable<any[]> {
+    if (!this.moduleHooks[hookId]) {
+      this.moduleHooks[hookId] = new Subject<any>();
+    }
+
+    // Create an Observable that will execute all hook functions when subscribed
+    return new Observable<any[]>((subscriber) => {
+      if (this.hookFunctions[hookId] && this.hookFunctions[hookId].length > 0) {
+        // Map each hook function to an Observable that can handle both synchronous values and Promises
+        const hookResults$ = from(this.hookFunctions[hookId]).pipe(
+          mergeMap((hookFunction) => {
+            let result;
+            try {
+              result = hookFunction(...args);
+              return from(Promise.resolve(result));
+            } catch (error) {
+              subscriber.error(error);
+              return [];
+            }
+          }),
+          toArray() // Collect all results into an array
+        );
+
+        // Subscribe to the hook results Observable
+        const subscription = hookResults$.subscribe({
+          next: (results) => {
+            // Emit all collected results to subscribers of this hook
+            this.moduleHooks[hookId].next(results);
+            subscriber.next(results);
+            subscriber.complete();
+          },
+          error: (err) => {
+            subscriber.error(err);
+          }
+        });
+
+        // Return cleanup function
+        return () => {
+          subscription.unsubscribe();
+        };
+      } else {
+        // No hook functions to execute, emit an empty array
+        subscriber.next([]);
+        subscriber.complete();
+        return () => {};
+      }
+    });
+  }
+}
+
+/**
+ * Provide modules configuration to Angular Dependency Injection
+ * Registers hook functions for later execution
+ *
+ * @param modules - Array of modules to provide
+ * @param namespace - Namespace to prefix hook IDs
+ * @returns Provider configuration for Angular DI
+ * @example
+ * ```ts
+ * // Define modules
+ * const modules = [
+ *   {
+ *     player: {
+ *       onMove: (player) => {
+ *         // Handle player movement
+ *       }
+ *     }
+ *   }
+ * ];
+ *
+ * // Provide modules
+ * const provider = provideModules(modules, 'game');
+ * ```
+ */
+export function provideModules(modules: any[], namespace: string, transform?: (modules: any, context: Context) => any) {
+  return {
+    provide: ModulesToken,
+    useFactory: (context: Context) => {
+      modules = transform ? transform(modules, context) : modules
+      return new Hooks(modules, namespace);
+    },
+  };
+}
+
+export function findModules(context: Context, namespace: string) {
+  let modules: any[] = []
+  for (let key in context['values']) {
+    if (key.endsWith('Module' + namespace)) {
+      modules.push(context['values'][key])
+    }
+  }
+  return modules
+}
+
+/**
+ * Create module providers from a token name and array of providers
+ * Transforms objects with server/client properties into separate ModuleServer and ModuleClient providers
+ *
+ * @param tokenName - The base token name for the module
+ * @param providers - Array of providers that can be regular providers or objects with server/client properties
+ * @returns Flattened array of providers with transformed server/client objects
+ * @example
+ * ```ts
+ * // Input: createModule('battle', [{ server: serverModule, client: clientModule }])
+ * // Output: [
+ * //   { provide: 'battleModuleServer', useValue: { server: serverModule, client: clientModule }, meta: { server: true, isModule: true } },
+ * //   { provide: 'battleModuleClient', useValue: { server: serverModule, client: clientModule }, meta: { client: true, isModule: true } }
+ * // ]
+ * 
+ * // Regular providers are passed through unchanged
+ * createModule('battle', [regularProvider, { server, client }])
+ * ```
+ */
+export function createModule(tokenName: string, providers:(Provider | Provider[] | ({ server?: any, client?: any }))[]) {
+  const results = providers.map(provider => {
+    const results: any[] = [];
+
+    if (!provider) {
+      return []
+    }
+    
+    if ('server' in provider) {
+      results.push({
+        provide: tokenName + 'ModuleServer',
+        useValue: provider,
+        meta: {
+          server: true,
+          isModule: true,
+        }
+      });
+    }
+    
+    if ('client' in provider) {
+      results.push({
+        provide: tokenName + 'ModuleClient',
+        useValue: provider,
+        meta: {
+          client: true,
+          isModule: true,
+        }
+      });
+    }
+    
+    // If neither server nor client properties, return the provider as-is
+    if (!('server' in provider) && !('client' in provider)) {
+      results.push(provider);
+    }
+    
+    return results;
+  }).flat(); // Flatten the array to handle multiple results per provider
+  return results.flat();
+}
+
+export function defineModule<T>(options: T) {
+  return options
+}