add transpiled files

drinking-code · drinking-code · commit 02698cf28f06 · 2022-09-18T17:26:58.000+02:00
diff --git a/.gitignore b/.gitignore
@@ -1 +0,0 @@
-lib
diff --git a/lib/array.d.ts b/lib/array.d.ts
@@ -0,0 +1,13 @@
+export default class InterceptedArray<T> extends Array {
+    private callback;
+    constructor(callback: (object: object, method: string, ...args: any) => void);
+    copyWithin(target: number, start: number, end?: number): this;
+    fill(value: T, start?: number, end?: number): this;
+    pop(): T | undefined;
+    push(...items: T[]): number;
+    reverse(): T[];
+    shift(): T | undefined;
+    sort(compareFn?: (a: T, b: T) => number): this;
+    splice(start: number, deleteCount?: number): T[];
+    unshift(...items: T[]): number;
+}
diff --git a/lib/array.js b/lib/array.js
@@ -0,0 +1,44 @@
+export default class InterceptedArray extends Array {
+    callback;
+    // intercepts only methods that change the object
+    constructor(callback) {
+        super();
+        this.callback = callback;
+    }
+    copyWithin(target, start, end) {
+        this.callback(this, 'copyWithin', target, start, end);
+        return super.copyWithin(target, start, end);
+    }
+    fill(value, start, end) {
+        this.callback(this, 'fill', value, start, end);
+        return super.fill(value, start, end);
+    }
+    pop() {
+        this.callback(this, 'pop');
+        return super.pop();
+    }
+    push(...items) {
+        this.callback(this, 'push', ...items);
+        return super.push(...items);
+    }
+    reverse() {
+        this.callback(this, 'reverse');
+        return super.reverse();
+    }
+    shift() {
+        this.callback(this, 'shift');
+        return super.shift();
+    }
+    sort(compareFn) {
+        this.callback(this, 'sort', compareFn);
+        return super.sort(compareFn);
+    }
+    splice(start, deleteCount) {
+        this.callback(this, 'splice', start, deleteCount);
+        return super.splice(start, deleteCount);
+    }
+    unshift(...items) {
+        this.callback(this, 'unshift', ...items);
+        return super.unshift(...items);
+    }
+}
diff --git a/lib/init-child.d.ts b/lib/init-child.d.ts
@@ -0,0 +1,2 @@
+import IPOS from './main.js';
+export default function initChild(this: IPOS): Promise<unknown>;
diff --git a/lib/init-child.js b/lib/init-child.js
@@ -0,0 +1,19 @@
+export default function initChild() {
+    let resolve;
+    const promise = new Promise(res => resolve = res);
+    this.messaging?.listenForType('sync', message => {
+        if (!message.fields)
+            return;
+        Object.entries(message.fields)
+            .map(([key, value]) => {
+            this.createStealthy(key, value);
+        });
+        this.messaging?.send('sync_ok');
+        resolve();
+    });
+    // register with parent process
+    this.messaging?.send('register');
+    if (this.messaging)
+        this.mountListeners(this.messaging);
+    return promise;
+}
diff --git a/lib/intercept.d.ts b/lib/intercept.d.ts
@@ -0,0 +1 @@
+export default function intercept(value: object, key: string, interceptCallback: (key: string, method: string, ...args: any) => void): object;
diff --git a/lib/intercept.js b/lib/intercept.js
@@ -0,0 +1,35 @@
+export default function intercept(value, key, interceptCallback) {
+    const arrayMutatingMethods = ['copyWithin', 'fill', 'pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'];
+    const objectMutatingMethods = [];
+    const mapMutatingMethods = ['clear', 'delete', 'set'];
+    const setMutatingMethods = ['add', 'clear', 'delete'];
+    const functionMutatingMethods = [];
+    const mutatingMethods = new Map();
+    mutatingMethods.set(Array, arrayMutatingMethods);
+    mutatingMethods.set({}.constructor, objectMutatingMethods);
+    mutatingMethods.set(Map, mapMutatingMethods);
+    mutatingMethods.set(Set, setMutatingMethods);
+    mutatingMethods.set(Function, functionMutatingMethods);
+    if (!mutatingMethods.has(value.constructor))
+        return value;
+    return new Proxy(value, {
+        get(target, name) {
+            if (Reflect.has(target, name) && mutatingMethods.get(value.constructor).includes(name)) {
+                const method = Reflect.get(target, name);
+                return (...args) => {
+                    interceptCallback(key, name, ...args);
+                    method.call(value, ...args);
+                };
+            }
+            else {
+                return Reflect.get(target, name);
+            }
+        },
+        set(target, name, value) {
+            // @ts-ignore
+            const result = (target[name] = value);
+            interceptCallback(key, '$$iposDefine', name, value);
+            return !!result;
+        },
+    });
+}
diff --git a/lib/intercept/array.d.ts b/lib/intercept/array.d.ts
@@ -0,0 +1,14 @@
+export default class InterceptedArray<T> extends Array {
+    private readonly callback;
+    constructor(callback: (object: object, method: string, ...args: any) => void);
+    static new<T>(arrayLike: ArrayLike<T>, callback: (object: object, method: string, ...args: any) => void): InterceptedArray<T>;
+    copyWithin(target: number, start: number, end?: number): this;
+    fill(value: T, start?: number, end?: number): this;
+    pop(): T | undefined;
+    push(...items: T[]): number;
+    reverse(): T[];
+    shift(): T | undefined;
+    sort(compareFn?: (a: T, b: T) => number): this;
+    splice(start: number, deleteCount?: number): T[];
+    unshift(...items: T[]): number;
+}
diff --git a/lib/intercept/array.js b/lib/intercept/array.js
@@ -0,0 +1,51 @@
+export default class InterceptedArray extends Array {
+    callback;
+    // intercepts only methods that change the object
+    constructor(callback) {
+        super();
+        this.callback = callback;
+    }
+    static new(arrayLike, callback) {
+        const interceptedArray = new InterceptedArray(callback);
+        for (let i = 0; i < arrayLike.length; i++) {
+            interceptedArray[i] = arrayLike[i];
+        }
+        return interceptedArray;
+    }
+    copyWithin(target, start, end) {
+        this.callback(this, 'copyWithin', target, start, end);
+        return super.copyWithin(target, start, end);
+    }
+    fill(value, start, end) {
+        this.callback(this, 'fill', value, start, end);
+        return super.fill(value, start, end);
+    }
+    pop() {
+        this.callback(this, 'pop');
+        return super.pop();
+    }
+    push(...items) {
+        this.callback(this, 'push', ...items);
+        return super.push(...items);
+    }
+    reverse() {
+        this.callback(this, 'reverse');
+        return super.reverse();
+    }
+    shift() {
+        this.callback(this, 'shift');
+        return super.shift();
+    }
+    sort(compareFn) {
+        this.callback(this, 'sort', compareFn);
+        return super.sort(compareFn);
+    }
+    splice(start, deleteCount) {
+        this.callback(this, 'splice', start, deleteCount);
+        return super.splice(start, deleteCount);
+    }
+    unshift(...items) {
+        this.callback(this, 'unshift', ...items);
+        return super.unshift(...items);
+    }
+}
diff --git a/lib/main.d.ts b/lib/main.d.ts
@@ -0,0 +1,33 @@
+/// <reference types="node" />
+import { ChildProcess } from 'child_process';
+import IPOSMessaging, { iposMessagingMessage, iposMessagingType } from './messaging.js';
+export default class IPOS {
+    private readonly fields;
+    private readonly fieldsRaw;
+    private fieldsReverseMap;
+    private processMessagingMap;
+    private readonly proxy;
+    protected messaging?: IPOSMessaging;
+    static new(): IPOS | Promise<IPOS>;
+    constructor();
+    /****************** MESSAGING *******************/
+    protected mountListeners(messaging: IPOSMessaging): void;
+    protected sendToAll(type: iposMessagingType, data?: {}): void;
+    /********************* GET **********************/
+    get(key: string): any;
+    private getRaw;
+    /******************** CREATE ********************/
+    create(key: string, value: any): void;
+    protected createStealthy(key: string, value: object): void;
+    protected performSet(message: iposMessagingMessage): void;
+    /******************** UPDATE ********************/
+    protected performUpdate(message: iposMessagingMessage): void;
+    private sendMethodCall;
+    /******************** DELETE ********************/
+    delete(key: string): boolean;
+    deleteStealthy(key: string): boolean;
+    performDelete(message: iposMessagingMessage): boolean | undefined;
+    /******************* PROCESS ********************/
+    addProcess(process: ChildProcess): Promise<void>;
+    private syncProcess;
+}
diff --git a/lib/main.js b/lib/main.js
@@ -0,0 +1,154 @@
+import initChild from './init-child.js';
+import IPOSMessaging from './messaging.js';
+import intercept from './intercept.js';
+export default class IPOS {
+    fields;
+    fieldsRaw;
+    fieldsReverseMap;
+    processMessagingMap;
+    proxy;
+    messaging;
+    static new() {
+        const ipos = new IPOS();
+        // was called on child process
+        if (process.send) {
+            return new Promise(async (resolve) => {
+                await initChild.call(ipos);
+                resolve(ipos);
+            });
+        }
+        return ipos;
+    }
+    constructor() {
+        this.fields = new Map();
+        this.fieldsRaw = new Map();
+        this.fieldsReverseMap = new Map();
+        this.processMessagingMap = new Map();
+        if (process.send) {
+            this.messaging = new IPOSMessaging(process);
+        }
+        // proxy makes all "target.fields" available as "actual" fields
+        this.proxy = new Proxy(this, {
+            get(target, name) {
+                if (Reflect.has(target, name)) {
+                    return Reflect.get(target, name);
+                }
+                else if (target.fields.has(name)) {
+                    return target.fields.get(name);
+                }
+            },
+            set(target, name, value) {
+                if (Reflect.has(target, name)) {
+                    throw Error(`Cannot change inherent property \`${name}\``);
+                }
+                else if (!target.fields.has(name)) {
+                    throw Error(`Cannot set unknown field \`${name}\`. Initialise a field with \`.create()\``);
+                }
+                else {
+                    target.create(name, value);
+                    return true;
+                }
+            },
+        });
+        return this.proxy;
+    }
+    /****************** MESSAGING *******************/
+    mountListeners(messaging) {
+        messaging.listenForType('update', (message) => this.performUpdate(message));
+        messaging.listenForType('set', (message) => this.performSet(message));
+        messaging.listenForType('delete', (message) => this.performDelete(message));
+    }
+    sendToAll(type, data) {
+        this.messaging?.send(type, data);
+        this.processMessagingMap.forEach(processMessaging => {
+            processMessaging.send(type, data);
+        });
+    }
+    /*public getNonIPOSMessages(process: ChildProcess, handler: (message: any) => any) {
+        this.processMessagingMap.get(process)?.getNonIPOSMessages(handler)
+    }*/
+    /********************* GET **********************/
+    get(key) {
+        return this.fields.get(key);
+    }
+    getRaw(key) {
+        return this.fields.get(key);
+    }
+    /******************** CREATE ********************/
+    create(key, value) {
+        this.createStealthy(key, value);
+        this.sendToAll('set', { key, value });
+    }
+    createStealthy(key, value) {
+        this.fieldsRaw.set(key, value);
+        if (typeof value === 'object')
+            value = intercept(value, key, (key, method, ...args) => this.sendMethodCall(key, method, ...args));
+        this.fields.set(key, value);
+        this.fieldsReverseMap.set(value, key);
+    }
+    performSet(message) {
+        if (!message.key || !message.value)
+            return;
+        this.createStealthy(message.key, message.value);
+    }
+    /******************** UPDATE ********************/
+    performUpdate(message) {
+        if (!message.do || !message.on)
+            return;
+        if (message.do === '$$iposDefine') {
+            if (!message.with)
+                return;
+            this.fieldsRaw.get(message.on)[message.with[0]] = message.with[1];
+        }
+        else {
+            this.fieldsRaw.get(message.on)[message.do](...(message.with ?? []));
+        }
+    }
+    sendMethodCall(key, method, ...args) {
+        this.sendToAll('update', {
+            do: method,
+            on: key,
+            with: Array.from(args)
+        });
+    }
+    /******************** DELETE ********************/
+    delete(key) {
+        this.sendToAll('delete', { key });
+        return this.deleteStealthy(key);
+    }
+    deleteStealthy(key) {
+        return this.fields.delete(key);
+    }
+    performDelete(message) {
+        if (!message.key)
+            return;
+        return this.deleteStealthy(message.key);
+    }
+    /******************* PROCESS ********************/
+    addProcess(process) {
+        if (!process.send)
+            throw new Error(`Process must have an ipc channel. Activate by passing "stdio: [<stdin>, <stdout>, <stderr>, 'ipc']" as an option.`);
+        const messaging = new IPOSMessaging(process);
+        let registered = false, resolve;
+        const promise = new Promise(res => resolve = res);
+        messaging.listenForType('register', () => {
+            if (registered)
+                return;
+            registered = true;
+            this.mountListeners(messaging);
+            this.processMessagingMap.set(process, messaging);
+            this.syncProcess(process)
+                .then(() => resolve());
+        });
+        return promise;
+    }
+    syncProcess(process) {
+        let resolve;
+        const promise = new Promise(res => resolve = res);
+        this.processMessagingMap.get(process)?.send('sync', { fields: this.fields });
+        this.processMessagingMap.get(process)?.listenOnceForType('sync_ok', () => {
+            resolve();
+        });
+        return promise;
+    }
+}
diff --git a/lib/messaging.d.ts b/lib/messaging.d.ts
diff --git a/lib/messaging.js b/lib/messaging.js
diff --git a/lib/serialize.d.ts b/lib/serialize.d.ts
diff --git a/lib/serialize.js b/lib/serialize.js
diff --git a/package.json b/package.json

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+import IPOS from './main.js';`
	`2`	`+export default function initChild(this: IPOS): Promise<unknown>;`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	`+export default function intercept(value: object, key: string, interceptCallback: (key: string, method: string, ...args: any) => void): object;`