big refactor

Author: samuelmtimbo

.prettierignore

@@ -1,5 +1,3 @@
-src/test/**
-
 lib
 
 build

README.md

@@ -14,7 +14,7 @@ The unit Programming Language was developed in close junction to the unit Progra
 
 unit is similar in concept to the Unix shell; for a seasoned programmer, unit should feel like the 2D evolution of the Command Line Interface (CLI) where units' (commands) inputs and outputs (stdin/stdout/stderr) can be piped together into a graph (script). In fact, unit can be thought of as a re-exploration of the [Unix Philosophy](https://en.wikipedia.org/wiki/Unix_philosophy) in the context of modern Software Engineering. 
 
-The unit system is set to grow into a modern and approachable Web Operating System, which is sandboxed by default, enabling a new era of Software Sharing and Collaboration.
+The unit system is set to grow into a simple and approachable Web Operating System, which is sandboxed by default, enabling a new era of Software Sharing and Collaboration.
 
 The broader Design Philosophy behind unit is discussed in [Concept](src/docs/concept/README.md).
 

public/index.html

@@ -189,6 +189,7 @@
         padding: 0;
         width: 100%;
         height: 100%;
+        font-size: 14px;
         box-sizing: border-box;
         background: transparent;
         /* touch-action: none; */

src/AsyncWorker.ts

@@ -1,4 +1,3 @@
-import { Callback } from './Callback'
 import {
   $C,
   $C_C,
@@ -52,7 +51,8 @@ import {
 } from './interface/async/$V'
 import { AsyncWrap } from './interface/async/AsyncWrap'
 import { RemotePort } from './RemotePort'
-import { Unlisten } from './Unlisten'
+import { Callback } from './types/Callback'
+import { Unlisten } from './types/Unlisten'
 
 export function AsyncWorker(client: RemotePort, _: string[]): any {
   return AsyncWrap(client, _, {

src/Class/$.ts

@@ -1,27 +1,29 @@
-import { EventEmitter_ } from '../EventEmitter'
+import { EventEmitter, EventEmitter_EE } from '../EventEmitter'
 import { deleteGlobalRef, setGlobalRef } from '../global'
-import { $_ } from '../interface/$_'
-import { PO } from '../interface/PO'
+import { Pod } from '../pod'
 import { System } from '../system'
-import { Unlisten } from '../Unlisten'
-import { Dict } from './../types/Dict'
+import { Dict } from '../types/Dict'
 
-export class $ extends EventEmitter_ implements $_ {
-  public __: string[] = []
-  public __id: string
+export type $_EE = { destroy: [] }
+
+export type $Events<_EE extends Dict<any[]>> = EventEmitter_EE<_EE & $_EE> &
+  $_EE
 
-  public __pod: PO | null = null
-  public __system: System | null = null
+export class $<
+  _EE extends $Events<_EE> & Dict<any[]> = $Events<$_EE>
+> extends EventEmitter<_EE> {
+  public __: string[] = []
+  public __pod: Pod
+  public __system: System
   public __global_id: string
 
-  constructor(__system: System = null) {
+  constructor(system: System, pod: Pod) {
     super()
 
-    this.__system = __system
+    this.__system = system
+    this.__pod = pod
 
-    if (this.__system) {
-      this.__global_id = setGlobalRef(this.__system, this)
-    }
+    this.__global_id = setGlobalRef(this.__system, this)
   }
 
   getGlobalId(): string {
@@ -36,40 +38,12 @@ export class $ extends EventEmitter_ implements $_ {
     return this.__system
   }
 
-  refPod(): PO {
+  refPod(): Pod {
     return this.__pod
   }
 
-  attach(__system: System): void {
-    // console.log('$', 'attach', __system, $pod)
-
-    if (__system === this.__system) {
-      return
-    }
-
-    this.__system = __system
-
-    this.__global_id = setGlobalRef(this.__system, this)
-
-    this.emit('_attach', __system)
-  }
-
-  dettach(): void {
-    if (this.__system) {
-      deleteGlobalRef(this.__system, this.__global_id)
-      this.__global_id = undefined
-    }
-
-    this.__system = null
-    this.__pod = null
-
-    this.emit('_dettach')
-  }
-
   destroy() {
-    if (this.__system) {
-      deleteGlobalRef(this.__system, this.__global_id)
-    }
+    deleteGlobalRef(this.__system, this.__global_id)
 
     this.emit('destroy')
   }

src/Class/Element/Element.ts renamed to src/Class/Element/index.ts

@@ -11,38 +11,59 @@ import {
   removeChild,
   removeParentChild,
   unregisterParentRoot,
-  unregisterRoot
+  unregisterRoot,
 } from '../../component/method'
-import { C } from '../../interface/C'
+import { C_EE } from '../../interface/C'
+import { Component_ } from '../../interface/component'
 import { E } from '../../interface/E'
+import { Pod } from '../../pod'
 import { System } from '../../system'
 import { Dict } from '../../types/Dict'
 import { UnitClass } from '../../types/UnitClass'
 import { forEach } from '../../util/array'
-import { Stateful } from '../Stateful'
+import { Stateful, StatefulEvents } from '../Stateful'
 import { ION, Opt } from '../Unit'
 
-export class Element<I = any, O = any> extends Stateful<I, O> implements E {
-  __ = ['U', 'C', 'V']
+export type Element_EE = C_EE & { call: [{ method: string; data: any[] }] }
 
-  public element = true
-
-  public _children: E[] = []
-  public _root: C[] = []
-  public _parent_root: C[] = []
-  public _parent_children: C[] = []
+export type ElementEvents<_EE extends Dict<any[]>> = StatefulEvents<
+  _EE & Element_EE
+> &
+  Element_EE
 
+export class Element<
+    I = any,
+    O = any,
+    _J extends Dict<any> = {},
+    _EE extends ElementEvents<_EE> & Dict<any[]> = ElementEvents<Element_EE>
+  >
+  extends Stateful<I, O, {}, _EE>
+  implements E
+{
+  __ = ['U', 'C', 'J', 'V']
 
-  public _slot: Dict<C> = {}
+  public element = true
 
-  constructor({ i = [], o = [] }: ION, opt: Opt = {}, system: System = null) {
+  public _children: Component_[] = []
+  public _root: Component_[] = []
+  public _parent_root: Component_[] = []
+  public _parent_children: Component_[] = []
+  public _slot: Dict<Component_> = {}
+
+  constructor(
+    { i = [], o = [] }: ION,
+    opt: Opt = {},
+    system: System,
+    pod: Pod
+  ) {
     super(
       {
         i,
         o,
       },
       opt,
-      system
+      system,
+      pod
     )
 
     this.addListener('play', this._play)
@@ -53,27 +74,27 @@ export class Element<I = any, O = any> extends Stateful<I, O> implements E {
     }
   }
 
-  registerRoot(component: C): number {
+  registerRoot(component: Component_): void {
     return registerRoot(this, this._root, component)
   }
 
-  unregisterRoot(component: C): void {
+  unregisterRoot(component: Component_): void {
     return unregisterRoot(this, this._root, component)
   }
 
-  registerParentRoot(component: C, slotName: string): void {
+  registerParentRoot(component: Component_, slotName: string): void {
     return registerParentRoot(this, this._parent_root, component, slotName)
   }
 
-  unregisterParentRoot(component: C): void {
+  unregisterParentRoot(component: Component_): void {
     return unregisterParentRoot(this, this._parent_root, component)
   }
 
-  appendParentChild(component: C<any, any>, slotName: string): void {
+  appendParentChild(component: Component_, slotName: string): void {
     return appendParentChild(this, this._parent_children, component, slotName)
   }
 
-  removeParentChild(component: C<any, any>): void {
+  removeParentChild(component: Component_): void {
     return removeParentChild(this, this._parent_children, component)
   }
 
@@ -97,15 +118,15 @@ export class Element<I = any, O = any> extends Stateful<I, O> implements E {
     throw pullChild(this, this._children, at)
   }
 
-  refChild(at: number): C {
+  refChild(at: number): Component_ {
     return refChild(this, this._children, at)
   }
 
-  refChildren(): C[] {
+  refChildren(): Component_[] {
     return refChildren(this, this._children)
   }
 
-  refSlot(slotName: string): C<any, any> {
+  refSlot(slotName: string): Component_ {
     const slot = this._slot[slotName]
 
     if (slot) {

src/Class/Functional/index.ts

@@ -1,15 +1,28 @@
-import { Primitive } from '../../Primitive'
+import { Pod } from '../../pod'
+import { Primitive, PrimitiveEvents } from '../../Primitive'
 import { System } from '../../system'
 import forEachKeyValue from '../../system/core/object/ForEachKeyValue/f'
+import { Dict } from '../../types/Dict'
 import { filterObj } from '../../util/object'
 import { ION, Opt } from '../Unit'
 import { Done } from './Done'
 
-export class Functional<I = {}, O = {}> extends Primitive<I, O> {
+export type Functional_EE = {}
+
+export type FunctionalEvents<_EE extends Dict<any[]>> = PrimitiveEvents<
+  _EE & Functional_EE
+> &
+  Functional_EE
+
+export class Functional<
+  I = {},
+  O = {},
+  _EE extends FunctionalEvents<_EE> = FunctionalEvents<Functional_EE>
+> extends Primitive<I, O, _EE> {
   private _looping: boolean = false
 
-  constructor({ i, o }: ION = {}, opt: Opt = {}, system: System = null) {
-    super({ i, o }, opt, system)
+  constructor({ i, o }: ION = {}, opt: Opt = {}, system: System, pod: Pod) {
+    super({ i, o }, opt, system, pod)
 
     this.addListener('take_err', () => {
       if (this._looping) {