reslib 1.0.0

package/build/observable/index.d.ts

@@ -0,0 +1,329 @@
+import 'reflect-metadata';
+/**
+ * @interface ObservableCallback
+ * Represents the callback options for observable events.
+ *
+ * This type defines a function that can be used as a callback for observable events.
+ * It accepts a variable number of arguments of any type and returns a value of any type.
+ *
+ * Callbacks of this type can be utilized in various event-driven scenarios, allowing
+ * flexibility in the number and types of parameters passed to the callback.
+ *
+ * @example
+ * ```typescript
+ * const callback: ObservableCallback = (arg1: string, arg2: number) => {
+ *   console.log(arg1, arg2); // Outputs the string and number passed to the callback
+ * };
+ *
+ * // Invoking the callback with different types of arguments
+ * callback("Event triggered", 42); // Outputs: Event triggered 42
+ * callback("Another event", 100);   // Outputs: Another event 100
+ * ```
+ */
+export type ObservableCallback = (...args: any[]) => any;
+/**
+ * Represents a collection of observable callbacks mapped to their respective event types,
+ * allowing for optional event handling.
+ *
+ * This type defines a record structure where each key corresponds to a specific event type,
+ * and the value is an array of callback functions associated with that event. The use of
+ * `Partial` allows for flexibility, meaning that not all event types need to have registered
+ * callbacks, making it suitable for scenarios where some events may not be utilized.
+ *
+ * @template TEventType - A generic type parameter that extends from `string`, representing
+ *                      the event types. By default, it is set to `string`, allowing for
+ *                      any string-based event name.
+ *
+ * @example
+ * // Defining specific event types
+ * type MyEvent = 'click' | 'hover' | 'scroll';
+ *
+ * // Creating a record of callbacks for the defined events
+ * const callbacks: ObservableCallbacks<MyEvent> = {
+ *   click: [
+ *     (event) => console.log('Click event handler 1', event),
+ *     (event) => console.log('Click event handler 2', event),
+ *   ],
+ *   hover: [
+ *     (event) => console.log('Hover event handler', event),
+ *   ],
+ *   // 'scroll' event has no callbacks registered
+ * };
+ *
+ * // Accessing the callbacks for a specific event
+ * const clickHandlers = callbacks.click;
+ * if (clickHandlers) {
+ *   clickHandlers.forEach(handler => handler('click')); // Logs: Click event handler 1 click
+ *   // Logs: Click event handler 2 click
+ * }
+ *
+ * @remarks
+ * This type is particularly useful in event-driven architectures where multiple callbacks
+ * need to be associated with different events. The use of `Partial` allows for a more
+ * flexible design, enabling developers to define only the events they are interested in
+ * without requiring all possible events to be present.
+ */
+export type ObservableCallbacks<TEventType extends string = string> = Partial<Record<TEventType | ObservableAllEventType, ObservableCallback[]>>;
+/**
+ * Represents a wildcard event type for observable systems.
+ *
+ * This type is used to signify that a callback should be triggered for all events within
+ * an observable system. It acts as a catch-all for any event, allowing developers to
+ * register handlers that respond to every event emitted by the observable.
+ *
+ * @example
+ * // Using the wildcard event type to listen for all events
+ * observable.on('*', (event, ...args) => {
+ *   console.log(`An event occurred: ${event}`, 'Arguments:', args);
+ * });
+ *
+ * @remarks
+ * The use of a wildcard event type can be useful for logging, debugging, or handling
+ * global events that are not specific to a single event type. However, it should be used
+ * judiciously, as it may lead to performance concerns if many events are emitted frequently.
+ */
+export type ObservableAllEventType = '*';
+export type Observable<TEventType extends string = string, Context = unknown> = {
+    _____isObservable?: boolean;
+    on: (event: TEventType, fn: ObservableCallback) => {
+        remove: () => any;
+    };
+    finally: (event: TEventType, fn: ObservableCallback) => Observable<TEventType>;
+    off: (event: TEventType, fn: ObservableCallback) => Observable<TEventType>;
+    trigger: (event: TEventType | ObservableAllEventType, ...args: any[]) => Observable<TEventType>;
+    offAll: () => Observable<TEventType>;
+    once: (event: TEventType, fn: ObservableCallback) => {
+        remove: () => any;
+    };
+    getEventCallBacks: () => ObservableCallbacks<TEventType>;
+} & Context;
+/**
+ * Returns an instance of the Observable interface.
+ * The `observableFactory` function creates a new observable object with methods to manage
+ * event listeners and trigger events. The returned observable object allows for adding,
+ * removing, and triggering event callbacks, as well as managing final callbacks that execute
+ * after all other callbacks for an event.
+ *
+ * @returns {Observable<TEventType>} A new instance of the observable object.
+ *
+ * @example
+ * ```typescript
+ * const observable = observableFactory();
+ * observable.on("event", (arg1, arg2) => {
+ *   console.log(arg1, arg2);
+ * });
+ * observable.trigger("event", "Hello", "World"); // Outputs: Hello World
+ * observable.on("event",function(){
+ *  console.log("event triggered");
+ * })
+ * ```
+ * @see {@link Observable} for more information on the observable interface.
+ * @see {@link ObservableCallbacks} for more information on the observable callbacks interface.
+ * @see {@link ObservableAllEventType} for more information on the observable all event type.
+ * @see {@link isObservable} for more information on the observable check function.
+ */
+export declare const observableFactory: <TEventType extends string = string, Context = unknown>(context?: Context) => Observable<TEventType, Context>;
+/**
+ * Creates an observable object based on the provided element.
+ *
+ * The `observable` function checks if the given element is already observable. If it is,
+ * the function returns the existing observable instance. If not, it creates a new observable
+ * instance and extends the provided element with observable methods. This allows the element
+ * to listen for events, trigger callbacks, and manage event listeners.
+ *
+ * @template TEventType - The type of the event. This can be any string or a custom type.
+ * @param {any} element - The element to make observable. This can be any object or value.
+ * @returns {Observable<TEventType>} The observable object, which includes methods for event handling.
+ *
+ * @example
+ * ```typescript
+ * const context = observable({});
+ * const testCb = (e) => console.log("test");
+ * context.on("test", testCb);
+ * context.trigger("test");
+ * context.off("test", testCb);
+ * context.offAll();
+ * ```
+ * @see {@link Observable} for more information on the observable interface.
+ * @see {@link ObservableCallbacks} for more information on the observable callbacks interface.
+ * @see {@link ObservableAllEventType} for more information on the observable all event type.
+ * @see {@link isObservable} for more information on the observable check function.
+ */
+export declare const observable: <TEventType extends string = string>(element: any) => Observable<TEventType>;
+/**
+ * Exports the ObservableClass that implements the Observable interface.
+ *
+ * This class provides a way to create observable objects that can emit events and have
+ * listeners attached to them. It encapsulates the observable functionality, allowing
+ * users to manage events and their corresponding callbacks in a structured manner.
+ *
+ * The ObservableClass is particularly useful in scenarios where you need to implement
+ * an event-driven architecture, enabling decoupled communication between different parts
+ * of an application.
+ * @template TEventType - The type of the event. This can be any string or a custom type.
+ */
+export declare class ObservableClass<TEventType extends string = string> implements Observable<TEventType> {
+    /**
+     * Flag indicating whether the object is observable.
+     *
+     * This property is used internally to identify instances of observable objects.
+     * It is set to true for all instances of this class.
+     */
+    readonly _____isObservable?: boolean | undefined;
+    /**
+     * The internal observable object that provides the observable functionality.
+     *
+     * This object is created using the observableFactory function and contains
+     * the core methods for managing event listeners and triggering events.
+     */
+    readonly _observable: {
+        _____isObservable?: boolean;
+        on: (event: TEventType, fn: ObservableCallback) => {
+            remove: () => any;
+        };
+        finally: (event: TEventType, fn: ObservableCallback) => /*elided*/ any;
+        off: (event: TEventType, fn: ObservableCallback) => /*elided*/ any;
+        trigger: (event: "*" | TEventType, ...args: any[]) => /*elided*/ any;
+        offAll: () => /*elided*/ any;
+        once: (event: TEventType, fn: ObservableCallback) => {
+            remove: () => any;
+        };
+        getEventCallBacks: () => Partial<Record<"*" | TEventType, ObservableCallback[]>>;
+    };
+    /**
+     * Listen to the given `event` and execute the `callback` each time an event is triggered.
+     *
+     * @param {TEventType} event - The event to listen to.
+     * @param {ObservableCallback} fn - The callback function to execute.
+     * @returns {{ remove: () => any }} An object with a `remove` method to remove the callback.
+     *
+     * @example
+     * ```typescript
+     * const observable = new ObservableClass();
+     * const subscription = observable.on("dataReceived", (data) => {
+     *   console.log("Data received:", data);
+     * });
+     * ```
+     */
+    on(event: TEventType, fn: ObservableCallback): {
+        remove: () => any;
+    };
+    /**
+     * Add a callback function to an event that will be triggered once.
+     *
+     * This method ensures that the callback is executed only the first time the event is triggered.
+     *
+     * @param {TEventType} event - The event to listen to.
+     * @param {ObservableCallback} fn - The callback function to execute.
+     * @returns {Observable<TEventType>} The observable object.
+     *
+     * @example
+     * ```typescript
+     * observable.finally("dataProcessed", () => {
+     *   console.log("Data has been processed.");
+     * });
+     * ```
+     */
+    finally(event: TEventType, fn: ObservableCallback): Observable<TEventType>;
+    /**
+     * Removes the given `event` listener.
+     *
+     * If `fn` is provided, this method removes the specific callback function from the event.
+     * If `fn` is not provided, it removes all callback functions associated with the event.
+     *
+     * @param {TEventType} event - The event to remove the listener from.
+     * @param {ObservableCallback} [fn] - The callback function to remove.
+     * @returns {Observable<TEventType>} The observable object.
+     *
+     * @example
+     * ```typescript
+     * observable.off("dataReceived", subscription.remove);
+     * ```
+     */
+    off(event: TEventType, fn: ObservableCallback): Observable<TEventType>;
+    /**
+     * Execute all callback functions that listen to the given `event`.
+     *
+     * If the last argument is a function, it will be treated as the final callback function
+     * to be executed after all other callbacks.
+     *
+     * @param {TEventType} event - The event to trigger.
+     * @param {...any[]} args - The arguments to pass to the callback functions.
+     * @returns {Observable<TEventType>} The observable object.
+     *
+     * @example
+     * ```typescript
+     * observable.trigger("dataReceived", { id: 1, value: "Hello" });
+     * ```
+     */
+    trigger(event: TEventType | ObservableAllEventType, ...args: any[]): Observable<TEventType>;
+    /**
+     * Remove all event bindings.
+     *
+     * This method clears all event listeners for the observable object.
+     *
+     * @returns {Observable<TEventType>} The observable object.
+     *
+     * @example
+     * ```typescript
+     * observable.offAll();
+     * ```
+     */
+    offAll(): Observable<TEventType>;
+    /**
+     * Listen to the given `event` and execute the `callback` at most once.
+     *
+     * This method ensures that the callback is executed only once, even if the event is triggered multiple times.
+     *
+     * @param {TEventType} event - The event to listen to.
+     * @param {ObservableCallback} fn - The callback function to execute.
+     * @returns {{ remove: () => any }} An object with a `remove` method to remove the callback.
+     *
+     * @example
+     * ```typescript
+     * const subscription = observable.once("dataLoaded", () => {
+     *   console.log("Data has been loaded.");
+     * });
+     * ```
+     */
+    once(event: TEventType, fn: ObservableCallback): {
+        remove: () => any;
+    };
+    /**
+     * Get all event callbacks.
+     *
+     * This method returns an object with event names as keys and arrays of callback functions as values.
+     *
+     * @returns {ObservableCallbacks<TEventType>} An object with event names as keys and arrays of callback functions as values.
+     *
+     * @example
+     * ```typescript
+     * const callbacks = observable.getEventCallBacks();
+     * console.log(callbacks);
+     * ```
+     */
+    getEventCallBacks(): ObservableCallbacks<TEventType>;
+}
+/**
+ * Checks if the given object is an observable element.
+ *
+ * An object is considered observable if it implements the Observable interface and has
+ * the following properties and methods:
+ * - `_____isObservable` set to `true`
+ * - `on` method
+ * - `trigger` method
+ * - `off` method
+ *
+ * @param {any} obj - The object to check.
+ * @returns {boolean} `true` if the object is observable, `false` otherwise.
+ *
+ * @example
+ * ```typescript
+ * const observable = new ObservableClass();
+ * console.log(isObservable(observable)); // true
+ *
+ * const nonObservable = {};
+ * console.log(isObservable(nonObservable)); // false
+ * ```
+ */
+export declare function isObservable(obj: any): boolean;

package/build/observable/index.js

@@ -0,0 +1 @@
+'use strict';require('reflect-metadata');var O=Object.defineProperty,h=Object.defineProperties;var g=Object.getOwnPropertyDescriptors;var T=Object.getOwnPropertySymbols;var C=Object.prototype.hasOwnProperty,k=Object.prototype.propertyIsEnumerable;var y=(t,e,l)=>e in t?O(t,e,{enumerable:true,configurable:true,writable:true,value:l}):t[e]=l,f=(t,e)=>{for(var l in e||(e={}))C.call(e,l)&&y(t,l,e[l]);if(T)for(var l of T(e))k.call(e,l)&&y(t,l,e[l]);return t},p=(t,e)=>h(t,g(e));var u=function(t){let e={},l={},o=Array.prototype.slice;return p(f({},Object.assign({},t)),{on:function(n,a){return a&&n&&(e[n]=e[n]||[]).push(a),{remove:()=>{this.off(n,a);}}},finally:function(n,a){return a&&n?((l[n]=l[n]||[]).push(a),this):this},off:function(n,a){if(!n)return this;if(n=="*"&&!a)e={};else if(a)for(var s=e[n],r=0,b;b=s&&s[r];++r)b==a&&s.splice(r--,1);return this},once:function(n,a){let s=(...r)=>{this.off(n,s),a.apply(this,r);};return this.on(n,s)},trigger:function(n,...a){if(!n)return this;let s,r,b,v=null;typeof a[a.length-1]=="function"&&(v=a.pop()),s=o.call(e[n]||[],0);let i=[];for(b=0;r=s[b];++b)typeof r=="function"&&i.push(r.apply(this,a));typeof e["*"]=="function"&&n!="*"&&(this.trigger(n,...a),this.trigger("*",...a));var E=o.call(l[n]||[],0);for(b=0;r=E[b];++b)r.call(this,i,a);return v&&v.call(this,i,a),this},offAll:function(){return e={},l={},this},getEventCallBacks:function(){return e}})},A=function(t){if(_(t))return t;let e=t||{},l=u();return Object.defineProperties(e,{_____isObservable:{value:true},on:{value:l.on.bind(e)},finally:{value:l.finally.bind(e)},off:{value:l.off.bind(e)},offAll:{value:l.offAll.bind(e)},once:{value:l.once.bind(e)},getEventCallBacks:{value:l.getEventCallBacks.bind(e)},trigger:{value:l.trigger.bind(e)}}),e},c=class{constructor(){this._____isObservable=true;this._observable=u();}on(e,l){return this._observable.on.call(this,e,l)}finally(e,l){return this._observable.finally.call(this,e,l)}off(e,l){return this._observable.off.call(this,e,l)}trigger(e,...l){return this._observable.trigger.call(this,e,...l)}offAll(){return this._observable.offAll.call(this)}once(e,l){return this._observable.once.call(this,e,l)}getEventCallBacks(){return this._observable.getEventCallBacks.call(this)}};function _(t){if(!t||["string","boolean","number"].includes(typeof t))return  false;try{return (t==null?void 0:t._____isObservable)===!0&&typeof(t==null?void 0:t.on)=="function"&&typeof(t==null?void 0:t.trigger)=="function"&&typeof(t==null?void 0:t.off)=="function"}catch(e){}return  false}exports.ObservableClass=c;exports.isObservable=_;exports.observable=A;exports.observableFactory=u;

package/build/platform/index.d.ts

@@ -0,0 +1,32 @@
+import 'reflect-metadata';
+/**
+  @group Platform
+ * Checks if the current environment is a web environment.
+ * This function checks for the presence of the `window` object and its `document` property,
+ * as well as the `document` object itself, to determine if the environment is a web environment.
+ * @returns {boolean} True if the environment is a web environment, false otherwise.
+ *
+ * @example
+ * ```typescript
+ * if (isWeb()) {
+ *   console.log("We're in a web environment!");
+ * } else {
+ *   console.log("We're not in a web environment.");
+ * }
+ * ```
+ */
+declare function isWeb(): boolean;
+export declare const Platform: {
+    isWeb: typeof isWeb;
+    isLinux: () => boolean;
+    isDarwin: () => boolean;
+    isWin32: () => boolean;
+    isNode: () => boolean;
+    isElectron: () => boolean;
+    isTouchDevice: () => boolean;
+    isServerSide: () => boolean;
+    isClientSide: () => boolean;
+    isAndroidMobileBrowser: () => boolean;
+    isReactNativeWebview: () => boolean;
+};
+export {};

package/build/platform/index.js

@@ -0,0 +1 @@
+'use strict';require('reflect-metadata');function t(){return typeof window!="undefined"&&(window==null?void 0:window.document)!==void 0&&typeof document!="undefined"&&typeof navigator!="undefined"}var n=()=>{var e;try{if(typeof process!="undefined"&&(process!=null&&process.versions)&&((e=process==null?void 0:process.versions)!=null&&e.node)||typeof global=="object"&&(global==null?void 0:global.toString.call(global))==="[object global]")return !0}catch(o){}return  false},i=()=>{var e,o;return !!(typeof window!="undefined"&&window&&typeof(window==null?void 0:window.process)=="object"&&((e=window==null?void 0:window.process)==null?void 0:e.type)==="renderer"||typeof process!="undefined"&&typeof(process==null?void 0:process.versions)=="object"&&((o=process.versions)!=null&&o.electron)||typeof navigator=="object"&&typeof navigator.userAgent=="string"&&String(navigator==null?void 0:navigator.userAgent).toLowerCase().indexOf("electron")>=0)},s=()=>{if(typeof document!="undefined"&&document)try{return document.createEvent("TouchEvent"),!0}catch(e){try{return "ontouchstart"in window||"onmsgesturechange"in window}catch(o){}}return  false},a=()=>typeof window=="undefined"&&typeof process!="undefined",r=()=>!!(typeof window!="undefined"&&typeof window=="object"&&window),c=()=>{if(!t()||typeof navigator!="object"||!navigator||typeof navigator.userAgent!="string")return  false;let e=navigator.userAgent.toLowerCase();return /android/i.test(e)},u=()=>{var e;return !r()||!(window!=null&&window.ReactNativeWebView)?false:typeof((e=window==null?void 0:window.ReactNativeWebView)==null?void 0:e.postMessage)=="function"},f=()=>n()&&process.platform==="darwin",d=()=>n()&&process.platform==="win32",l=()=>n()&&process.platform==="linux",b={isWeb:t,isLinux:l,isDarwin:f,isWin32:d,isNode:n,isElectron:i,isTouchDevice:s,isServerSide:a,isClientSide:r,isAndroidMobileBrowser:c,isReactNativeWebview:u};exports.Platform=b;