@k8ts/instruments 0.4.5 → 0.4.7

package/src/cmd/cli-term.ts

@@ -1,3 +1,4 @@
+import { displayers } from "../displayers"
 import { InstrumentsError } from "../error"
 import type { CliValue } from "./types"
 
@@ -15,6 +16,9 @@ export class CliFlag {
 
 export type ValueTermJoiner = "=" | " "
 
+@displayers({
+    simple: s => s.str("=")
+})
 export class CliOptionValue {
     constructor(
         private readonly key: string,

package/src/displayers/bind.ts

@@ -0,0 +1,30 @@
+import { List, Map } from "immutable"
+
+export function getPrototypes(target: object) {
+    const prototypes = []
+    let proto = Object.getPrototypeOf(target)
+    while (proto) {
+        prototypes.push(proto)
+        proto = Object.getPrototypeOf(proto)
+    }
+    return List(prototypes)
+}
+
+export function bind_own_methods() {
+    return <F extends abstract new (...args: any[]) => any>(target: F) => {
+        for (const [key, desc] of Map(Object.getOwnPropertyDescriptors(target.prototype))) {
+            if (!desc.value || typeof desc.value !== "function") {
+                continue
+            }
+            const descValue = desc.value
+            delete desc.value
+            delete desc.writable
+            Object.defineProperty(target.prototype, key, {
+                ...desc,
+                get() {
+                    return descValue.bind(this)
+                }
+            })
+        }
+    }
+}

package/src/displayers/displayers.ts

@@ -31,7 +31,7 @@ class DisplayerDecorator {
             return result
         }
     }
-    implement(ctor: abstract new (...args: any[]) => object, input: Displayers.In) {
+    implement(ctor: typeof PrivateCtorExemplar, input: Displayers.In) {
         this._system.set(ctor.prototype, input)
         const decorator = this
         Object.defineProperties(ctor.prototype, {
@@ -123,25 +123,29 @@ class DisplayerDecorator {
     }
 
     get decorator() {
-        return Object.assign(
-            <
-                Target extends abstract new (...args: any[]) => object,
-                Impl extends Displayers.In<InstanceType<Target>>
-            >(
-                input: Impl
-            ) => {
-                return (ctor: Target) => {
-                    this.implement(ctor, input as any)
-                    return ctor
-                }
-            },
-            {
-                get: (target: object): Displayers.Out => {
-                    return this.get(target)
-                }
+        return <Target extends AnyCtor<any>, Impl extends Displayers.In<InstanceTypeOf<Target>>>(
+            input: Impl
+        ) => {
+            return (ctor: Target) => {
+                this.implement(ctor, input as any)
             }
-        )
+        }
     }
 }
+
+export type PrivateCtor<T extends object> = typeof PrivateCtorExemplar & {
+    prototype: T
+}
+
+export type PublicCtor<T extends object> = abstract new (...args: any[]) => T
+
+export type AnyCtor<T extends object> = PrivateCtor<T> | PublicCtor<T>
+
+export type InstanceTypeOf<T extends AnyCtor<any>> =
+    T extends PrivateCtor<infer U> ? U : T extends PublicCtor<infer U> ? U : never
+abstract class PrivateCtorExemplar {
+    protected constructor(...args: any[]) {}
+}
+
 export const Displayers = new DisplayerDecorator()
 export const displayers = Displayers.decorator

package/src/forward-exports/delayed-exports.ts

@@ -1,5 +1,6 @@
 import { seq } from "doddle"
 import { ProxyOperationError } from "../error"
+import { ResourceEntity } from "../graph"
 import { Origin } from "../graph/origin-node"
 import type { LiveRefable } from "../reference"
 import { ForwardRef } from "../reference"
@@ -8,7 +9,7 @@ export type FutureExports<Exps extends LiveRefable> = FutureExports.FutureExport
 export namespace FutureExports {
     export type FutureExports<Exps extends LiveRefable> = _ExportsByKey<Exps>
     type _ExportsByKey<Exports extends LiveRefable = LiveRefable> = {
-        [E in Exports as `${E["kind"]["name"]}/${E["node"]["key"]["name"]}`]: ForwardRef<E>
+        [E in Exports as `${E["kind"]["name"]}/${E["name"]}`]: ForwardRef<E>
     }
     export interface Props<
         Actual extends object = object,
@@ -79,6 +80,7 @@ export namespace FutureExports {
                 origin: this._props.origin,
                 namespace: this._props.origin.meta.tryGet("namespace"),
                 resolver: this.seq
+                    .as<ResourceEntity>()
                     .find(exp => exp.node.key.equals(refKey))
                     .map(x => {
                         if (x == null) {

package/src/graph/base-node.ts

@@ -8,7 +8,6 @@ import { Relation } from "./dependencies"
 export interface BaseEntity<Node extends BaseNode<Node>> {
     readonly node: Node
 
-    readonly shortFqn: string
     readonly kind: Kind.Identifier
     readonly name: string
 }

package/src/graph/resource-node.ts

@@ -19,7 +19,7 @@ import { Relations } from "./relations"
         }
         const resourceName = chalk.blueBright(resource.name)
         const mainPart = `${kindName}/${resourceName}`
-        let originPart = `${displayers.get(resource.origin).prefix!()}`
+        let originPart = `${Displayers.get(resource.origin).prefix!()}`
         let text = ""
 
         text += mainPart

package/src/ports/set.ts

@@ -54,6 +54,10 @@ export class PortSet<Names extends string = never> {
         return this._apply(map => map.filter((_, key) => name.includes(key as InNames))) as any
     }
 
+    get names() {
+        return this._map.keySeq().toArray() as Names[]
+    }
+
     get(name: Names): PortSetEntry {
         if (!this._map.has(name)) {
             throw new PortError(`Port ${name} not found`)

package/src/ports/tools/entry.ts

@@ -1,4 +1,5 @@
 import { Map } from "immutable"
+import { Ip4 } from "../../_ip"
 import { PortSet } from "../set"
 import type {
     InputPortSetEntry,
@@ -13,7 +14,9 @@ function portSetEntry(name: string, value: InputPortSetEntry): PortSetEntry {
     return {
         name,
         port: value.port,
-        protocol: value.protocol.toUpperCase() as Protocol
+        protocol: value.protocol.toUpperCase() as Protocol,
+        hostIp: value.hostIp ? new Ip4(value.hostIp) : undefined,
+        hostPort: value.hostPort
     }
 }
 
@@ -37,7 +40,5 @@ export function portRecordInput(
         return record.values
     }
     const inputMap = Map(record)
-    return inputMap
-        .map((v, k) => parsePortInput(k, v))
-        .map((value, key) => portSetEntry(key, value))
+    return inputMap.map((v, k) => parsePortInput(k, v))
 }

package/src/ports/types.ts

@@ -1,3 +1,5 @@
+import { Ip4, Ip4_String } from "../_ip"
+
 export interface PortSpecObj {
     port: Port
     protocol: Protocol
@@ -18,21 +20,19 @@ export interface PortSetEntry {
     name: string
     port: number
     protocol: Protocol
+    hostIp?: Ip4
+    hostPort?: number
 }
 
 export interface InputPortSetEntry {
     port: Port
     protocol: InputProtocol
+    hostIp?: Ip4_String
+    hostPort?: Port
 }
 
 export type InputPortSetSpec = InputPortSetEntry | InputPort | InputPortProto
 
-export interface InputPortMapEntry {
-    source: Port
-    target: Port
-    protocol: InputProtocol
-}
-
 export type InputPortSetRecord<Names extends string = string> = {
     [K in Names]: InputPortSetSpec
 }

package/src/reference/index.ts

@@ -1,3 +1,3 @@
 export { RefKey } from "../ref-key"
 export { ForwardRef } from "./forward-ref"
-export { Kinded, LiveRefable } from "./refable"
+export { Kinded, LiveRefable, Refable } from "./refable"

package/src/reference/refable.ts

@@ -1,11 +1,12 @@
 import type { Kind } from "../api-kind"
-import type { RefKey } from "../ref-key"
 
-export type Kinded = { kind: Kind.Kind }
-export type Refable<Kind extends string, Name extends string> = {
-    node: {
-        key: RefKey<Kind, Name>
-    }
+export type Kinded<K extends Kind.IdentParent = Kind.IdentParent> = { kind: K }
+
+export type Refable<
+    Kind extends Kind.IdentParent = Kind.IdentParent,
+    Name extends string = string
+> = Kinded<Kind> & {
+    name: Name
 }
 export type LiveRefable<Object extends Kinded = Kinded, Name extends string = string> = Object &
-    Refable<Object["kind"]["name"], Name>
+    Refable<Object["kind"], Name>