@esportsplus/reactivity 0.1.22 → 0.1.23

package/build/macro.d.ts

@@ -2,7 +2,7 @@ import CustomFunction from '@esportsplus/custom-function';
 import { Computed, Options } from './types';
 type Function<A extends unknown[], R> = Computed<(...args: A) => R>['fn'];
 declare class Macro<A extends unknown[], R> extends CustomFunction {
-    #private;
+    private factory;
     constructor(fn: Function<A, R>, options?: Options);
     dispose(): void;
 }

package/build/macro.js

@@ -1,15 +1,15 @@
 import CustomFunction from '@esportsplus/custom-function';
 import { computed } from './signal';
 class Macro extends CustomFunction {
-    #factory;
+    factory;
     constructor(fn, options = {}) {
         super((...args) => {
-            return this.#factory.get()(...args);
+            return this.factory.get()(...args);
         });
-        this.#factory = computed(fn, options);
+        this.factory = computed(fn, options);
     }
     dispose() {
-        this.#factory.dispose();
+        this.factory.dispose();
     }
 }
 export default (fn, options = {}) => {

package/build/reactive/array.d.ts

@@ -26,7 +26,7 @@ type Events<T> = {
 };
 type Node<T extends Object> = ReactiveObject<T>;
 declare class ReactiveArray<T> extends Array<T> {
-    #private;
+    private signal;
     constructor(data: T[]);
     set length(n: number);
     private trigger;
@@ -45,7 +45,7 @@ declare class ReactiveArray<T> extends Array<T> {
     unshift(...items: T[]): number;
 }
 declare class ReactiveObjectArray<T extends Object> extends ReactiveArray<Node<T>> {
-    #private;
+    private options;
     constructor(data: T[], options?: Options);
     fill(): never;
     reverse(): never;

package/build/reactive/array.js

@@ -11,10 +11,10 @@ function unsupported(method) {
     throw new Error(`Reactivity: '${method}' is not supported on reactive object array`);
 }
 class ReactiveArray extends Array {
-    #signal;
+    signal;
     constructor(data) {
         super(...data);
-        this.#signal = signal(false);
+        this.signal = signal(false);
     }
     set length(n) {
         if (n > this.length) {
@@ -23,13 +23,13 @@ class ReactiveArray extends Array {
         this.splice(n);
     }
     trigger() {
-        this.#signal.set(!this.#signal.value);
+        this.signal.set(!this.signal.value);
     }
     dispatch(event, data) {
-        this.#signal.dispatch(event, data);
+        this.signal.dispatch(event, data);
     }
     dispose() {
-        this.#signal.dispose();
+        this.signal.dispose();
     }
     fill(value, start, end) {
         super.fill(value, start, end);
@@ -38,10 +38,10 @@ class ReactiveArray extends Array {
         return this;
     }
     on(event, listener) {
-        this.#signal.on(event, listener);
+        this.signal.on(event, listener);
     }
     once(event, listener) {
-        this.#signal.once(event, listener);
+        this.signal.once(event, listener);
     }
     pop() {
         let item = super.pop();
@@ -90,7 +90,7 @@ class ReactiveArray extends Array {
         return removed;
     }
     track() {
-        this.#signal.get();
+        this.signal.get();
     }
     unshift(...items) {
         let length = super.unshift(...items);
@@ -100,10 +100,10 @@ class ReactiveArray extends Array {
     }
 }
 class ReactiveObjectArray extends ReactiveArray {
-    #options;
+    options;
     constructor(data, options = {}) {
         super(factory(data, options));
-        this.#options = options;
+        this.options = options;
     }
     fill() {
         return unsupported('fill');
@@ -115,7 +115,7 @@ class ReactiveObjectArray extends ReactiveArray {
         return dispose(super.pop());
     }
     push(...values) {
-        return super.push(...factory(values, this.#options));
+        return super.push(...factory(values, this.options));
     }
     shift() {
         return dispose(super.shift());
@@ -124,10 +124,10 @@ class ReactiveObjectArray extends ReactiveArray {
         return unsupported('sort');
     }
     splice(start, deleteCount = super.length, ...values) {
-        return dispose(super.splice(start, deleteCount, ...factory(values, this.#options)));
+        return dispose(super.splice(start, deleteCount, ...factory(values, this.options)));
     }
     unshift(...values) {
-        return super.unshift(...factory(values, this.#options));
+        return super.unshift(...factory(values, this.options));
     }
 }
 export { ReactiveArray, ReactiveObjectArray };

package/build/resource.d.ts

@@ -2,7 +2,9 @@ import CustomFunction from '@esportsplus/custom-function';
 import { Options } from './types';
 type Function<A extends unknown[], R extends Promise<unknown>> = (...args: A) => R;
 declare class Resource<A extends unknown[], R extends Promise<unknown>> extends CustomFunction {
-    #private;
+    private arguments;
+    private okay;
+    private response;
     stop: boolean | null;
     constructor(fn: Function<A, R>, options?: Options);
     get data(): Awaited<R>;

package/build/resource.js

@@ -1,48 +1,48 @@
 import CustomFunction from '@esportsplus/custom-function';
 import { signal } from './signal';
 class Resource extends CustomFunction {
-    #data;
-    #input;
-    #ok;
+    arguments;
+    okay;
+    response;
     stop = null;
     constructor(fn, options = {}) {
         super((...args) => {
             this.stop = null;
-            this.#input.set(args);
-            this.#ok.set(null);
+            this.arguments.set(args);
+            this.okay.set(null);
             fn(...args)
                 .then((value) => {
                 if (this.stop === true) {
                     return;
                 }
-                this.#data.set(value);
-                this.#ok.set(true);
+                this.response.set(value);
+                this.okay.set(true);
             })
                 .catch(() => {
                 if (this.stop === true) {
                     return;
                 }
-                this.#data.set(undefined);
-                this.#ok.set(false);
+                this.response.set(undefined);
+                this.okay.set(false);
             });
         });
-        this.#data = signal(undefined, options);
-        this.#input = signal(null, options);
-        this.#ok = signal(null, options);
+        this.response = signal(undefined, options);
+        this.arguments = signal(null, options);
+        this.okay = signal(null, options);
     }
     get data() {
-        return this.#data.get();
+        return this.response.get();
     }
     get input() {
-        return this.#input.get();
+        return this.arguments.get();
     }
     get ok() {
-        return this.#ok.get();
+        return this.okay.get();
     }
     dispose() {
-        this.#data.dispose();
-        this.#input.dispose();
-        this.#ok.dispose();
+        this.arguments.dispose();
+        this.okay.dispose();
+        this.response.dispose();
     }
 }
 export default (fn, options = {}) => {

package/package.json

@@ -16,5 +16,5 @@
         "prepublishOnly": "npm run build"
     },
     "types": "build/index.d.ts",
-    "version": "0.1.22"
+    "version": "0.1.23"
 }

package/src/macro.ts

@@ -7,19 +7,19 @@ type Function<A extends unknown[], R> = Computed<(...args: A) => R>['fn'];
 
 
 class Macro<A extends unknown[], R> extends CustomFunction {
-    #factory: Computed<(...args: A) => R>;
+    private factory: Computed<(...args: A) => R>;
 
 
     constructor(fn: Function<A,R>, options: Options = {}) {
         super((...args: A) => {
-            return this.#factory.get()(...args);
+            return this.factory.get()(...args);
         });
-        this.#factory = computed(fn, options);
+        this.factory = computed(fn, options);
     }
 
 
     dispose() {
-        this.#factory.dispose();
+        this.factory.dispose();
     }
 }
 

package/src/reactive/array.ts

@@ -33,12 +33,12 @@ function unsupported(method: string): never {
 
 
 class ReactiveArray<T> extends Array<T> {
-    #signal: Signal<boolean>;
+    private signal: Signal<boolean>;
 
 
     constructor(data: T[]) {
         super(...data);
-        this.#signal = signal(false);
+        this.signal = signal(false);
     }
 
 
@@ -52,16 +52,16 @@ class ReactiveArray<T> extends Array<T> {
 
 
     private trigger() {
-        this.#signal.set(!this.#signal.value);
+        this.signal.set(!this.signal.value);
     }
 
 
     dispatch<E extends keyof Events<T>>(event: E, data?: Events<T>[E]) {
-        this.#signal.dispatch(event, data);
+        this.signal.dispatch(event, data);
     }
 
     dispose() {
-        this.#signal.dispose();
+        this.signal.dispose();
     }
 
     fill(value: T, start?: number, end?: number) {
@@ -74,11 +74,11 @@ class ReactiveArray<T> extends Array<T> {
     }
 
     on<E extends keyof Events<T>>(event: E, listener: Listener<Events<T>[E]>) {
-        this.#signal.on(event, listener);
+        this.signal.on(event, listener);
     }
 
     once<E extends keyof Events<T>>(event: E, listener: Listener<Events<T>[E]>) {
-        this.#signal.once(event, listener);
+        this.signal.once(event, listener);
     }
 
     pop() {
@@ -146,7 +146,7 @@ class ReactiveArray<T> extends Array<T> {
     }
 
     track() {
-        this.#signal.get();
+        this.signal.get();
     }
 
     unshift(...items: T[]) {
@@ -164,12 +164,12 @@ class ReactiveArray<T> extends Array<T> {
 // - @ts-ignore flags are supressing a type mismatch error
 // - Input values are being transformed by this class into nodes
 class ReactiveObjectArray<T extends Object>  extends ReactiveArray<Node<T>> {
-    #options: Options;
+    private options: Options;
 
 
     constructor(data: T[], options: Options = {}) {
         super( factory(data, options) );
-        this.#options = options;
+        this.options = options;
     }
 
 
@@ -187,7 +187,7 @@ class ReactiveObjectArray<T extends Object>  extends ReactiveArray<Node<T>> {
 
     // @ts-ignore
     push(...values: T[]) {
-        return super.push(...factory(values, this.#options));
+        return super.push(...factory(values, this.options));
     }
 
     shift() {
@@ -200,12 +200,12 @@ class ReactiveObjectArray<T extends Object>  extends ReactiveArray<Node<T>> {
 
     // @ts-ignore
     splice(start: number, deleteCount: number = super.length, ...values: T[]) {
-        return dispose( super.splice(start, deleteCount, ...factory(values, this.#options)) );
+        return dispose( super.splice(start, deleteCount, ...factory(values, this.options)) );
     }
 
     // @ts-ignore
     unshift(...values: T[]) {
-        return super.unshift(...factory(values, this.#options));
+        return super.unshift(...factory(values, this.options));
     }
 }
 

package/src/resource.ts

@@ -7,9 +7,9 @@ type Function<A extends unknown[], R extends Promise<unknown>> = (...args: A) =>
 
 
 class Resource<A extends unknown[], R extends Promise<unknown>> extends CustomFunction {
-    #data: Signal<Awaited<R>>;
-    #input: Signal<A | null>;
-    #ok: Signal<boolean | null>;
+    private arguments: Signal<A | null>;
+    private okay: Signal<boolean | null>;
+    private response: Signal<Awaited<R>>;
 
     stop: boolean | null = null;
 
@@ -18,8 +18,8 @@ class Resource<A extends unknown[], R extends Promise<unknown>> extends CustomFu
         super((...args: A) => {
             this.stop = null;
 
-            this.#input.set(args);
-            this.#ok.set(null);
+            this.arguments.set(args);
+            this.okay.set(null);
 
             fn(...args)
                 .then((value) => {
@@ -27,41 +27,41 @@ class Resource<A extends unknown[], R extends Promise<unknown>> extends CustomFu
                         return;
                     }
 
-                    this.#data.set(value as Awaited<R>);
-                    this.#ok.set(true);
+                    this.response.set(value as Awaited<R>);
+                    this.okay.set(true);
                 })
                 .catch(() => {
                     if (this.stop === true) {
                         return;
                     }
 
-                    this.#data.set(undefined as Awaited<R>);
-                    this.#ok.set(false);
+                    this.response.set(undefined as Awaited<R>);
+                    this.okay.set(false);
                 });
         });
-        this.#data = signal(undefined as Awaited<R>, options);
-        this.#input = signal<A | null>(null, options);
-        this.#ok = signal<boolean | null>(null, options);
+        this.response = signal(undefined as Awaited<R>, options);
+        this.arguments = signal<A | null>(null, options);
+        this.okay = signal<boolean | null>(null, options);
     }
 
 
     get data() {
-        return this.#data.get();
+        return this.response.get();
     }
 
     get input() {
-        return this.#input.get();
+        return this.arguments.get();
     }
 
     get ok() {
-        return this.#ok.get();
+        return this.okay.get();
     }
 
 
     dispose() {
-        this.#data.dispose();
-        this.#input.dispose();
-        this.#ok.dispose();
+        this.arguments.dispose();
+        this.okay.dispose();
+        this.response.dispose();
     }
 }