@k8ts/instruments 0.5.3 → 0.6.2

package/src/resources/objects.ts

@@ -1,99 +0,0 @@
-import { Map, Set } from "immutable"
-import { isEmpty, merge } from "lodash"
-import { string, type Parjser } from "parjs"
-import { mapConst, or } from "parjs/combinators"
-import { InstrumentsError } from "../error"
-import type { UnitParser, UnitValue } from "../units"
-import { createResourceParser } from "./parser"
-import type { mt_Resource_Input_Map, mt_Resource_Unit_Map, ReqLimit } from "./types"
-
-export class ResourcesMap<const RM extends mt_Resource_Unit_Map<RM>> {
-    constructor(private _map: Map<string, ReqLimit>) {}
-
-    toObject() {
-        const kubernetesForm = this._map.map((value, key) => {
-            const result = {} as any
-            if (value.request) {
-                result.requests = {
-                    [key]: value.request.str
-                }
-            }
-            if (value.limit) {
-                result.limits = {
-                    [key]: value.limit.str
-                }
-            }
-            if (!isEmpty(result)) {
-                return result
-            }
-            return undefined
-        })
-
-        return merge({}, ...kubernetesForm.values())
-    }
-}
-
-export class ResourcesSpec<const RM extends mt_Resource_Unit_Map<RM>> {
-    readonly _unitParsers: Map<string, Parjser<UnitValue | undefined>>
-    readonly _reqLimitParsers: Map<string, Parjser<ReqLimit>>
-    constructor(_unitMap: Map<string, UnitParser>) {
-        const questionMarkParser = string("?").pipe(mapConst(undefined))
-        this._unitParsers = _unitMap.map(parser => parser.parser.pipe(or(questionMarkParser)))
-        this._reqLimitParsers = _unitMap.map(parser => createResourceParser(parser))
-    }
-
-    private _parseUnitValue(resource: string, input: string): UnitValue | undefined {
-        const pUnitValue = this._unitParsers.get(input)
-        if (!pUnitValue) {
-            throw new InstrumentsError(`No parser found for ${input}`)
-        }
-        return pUnitValue.parse(input).value
-    }
-
-    private _parseReqLimit(resource: string, input: string): ReqLimit {
-        const pReqLimit = this._reqLimitParsers.get(resource)
-        if (!pReqLimit) {
-            throw new InstrumentsError(`No parser found for ${resource}`)
-        }
-        return pReqLimit.parse(input).value
-    }
-    __INPUT__!: mt_Resource_Input_Map<RM>
-
-    parse<const R extends mt_Resource_Input_Map<RM>>(input: R): ResourcesMap<RM> {
-        const allKeys = Set([...Object.keys(input), ...this._unitParsers.keys()]).toMap()
-        const map = allKeys.map((_, key) => {
-            const value = input[key as keyof R]
-            const pUnitValue = this._unitParsers.get(key)
-            if (!pUnitValue) {
-                throw new InstrumentsError(`No parser found for ${String(key)}`)
-            }
-            if (!value) {
-                throw new InstrumentsError(`No value found for ${String(key)}`)
-            }
-
-            if (Array.isArray(value)) {
-                const [req, limit] = value.map(v => {
-                    return pUnitValue.parse(v as any).value
-                })
-                return {
-                    request: req,
-                    limit: limit
-                }
-            } else if (typeof value === "string") {
-                return this._parseReqLimit(key as string, value)
-            } else {
-                return {
-                    request: this._parseUnitValue(key as string, value.request),
-                    limit: this._parseUnitValue(key as string, value.limit)
-                }
-            }
-        })
-        return new ResourcesMap(map as Map<string, ReqLimit>)
-    }
-
-    static make<const RM extends mt_Resource_Unit_Map<RM>>(unitMap: {
-        [K in keyof RM]: UnitParser<RM[K]>
-    }) {
-        return new ResourcesSpec<RM>(Map(unitMap) as Map<string, UnitParser>)
-    }
-}

package/src/resources/types.ts

@@ -1,26 +0,0 @@
-import type { UnitValue } from "../units/unit-parser"
-export type _limit_term<Unit extends string> = `${number}${Unit}` | "?"
-
-export interface InputReqLimitObject<Unit extends string> {
-    readonly request: _limit_term<Unit>
-    readonly limit: _limit_term<Unit>
-}
-export type InputReqLimitArray<Unit extends string> = [_limit_term<Unit>, _limit_term<Unit>]
-export type mt_Resource_Unit_Map<T> = Record<keyof T, string>
-
-type spaces = "" | " " | "  "
-export type InputReqLimitString<U extends string> =
-    `${_limit_term<U>}${spaces}->${spaces}${_limit_term<U>}`
-export type InputIdenticalReqLimitString<U extends string> = `=${_limit_term<U>}`
-export interface ReqLimit<Unit extends string = string> {
-    readonly request?: UnitValue<Unit>
-    readonly limit?: UnitValue<Unit>
-}
-export type InputReqLimit<Unit extends string> =
-    | InputReqLimitString<Unit>
-    | InputIdenticalReqLimitString<Unit>
-    | InputReqLimitObject<Unit>
-    | InputReqLimitArray<Unit>
-export type mt_Resource_Input_Map<ResourceUnit extends mt_Resource_Unit_Map<ResourceUnit>> = {
-    [K in keyof ResourceUnit]: InputReqLimit<ResourceUnit[K]>
-}

package/src/types.ts

@@ -1,13 +0,0 @@
-export type BuiltIn =
-    | Function
-    | Error
-    | Date
-    | {
-          readonly [Symbol.toStringTag]: string
-      }
-    | RegExp
-    | Generator
-
-export type WritableDeep<O> = {
-    -readonly [K in keyof O]: O[K] extends BuiltIn ? O[K] : WritableDeep<O[K]>
-}

package/src/units/unit-parser.ts

@@ -1,63 +0,0 @@
-import { Set } from "immutable"
-import { int, letter, type Parjser } from "parjs"
-import { many1, map, stringify, then } from "parjs/combinators"
-import { InstrumentsError } from "../error"
-const pUnit = letter().pipe(many1(2), stringify())
-
-const pValueUnit = int().pipe(
-    then(pUnit),
-    map(arr => {
-        const [value, unit] = arr
-        return { value, unit }
-    })
-)
-export class UnitValue<Unit extends string = string> {
-    constructor(
-        readonly unit: Unit,
-        readonly value: number,
-        readonly type: string
-    ) {}
-
-    get str() {
-        return `${this.value}${this.unit}`
-    }
-
-    toString() {
-        return this.str
-    }
-}
-
-export class UnitParser<const Unit extends string = string> {
-    readonly parser: Parjser<UnitValue<Unit>>
-    constructor(
-        private readonly unitType: string,
-        private readonly _units: Set<Unit>
-    ) {
-        this.parser = pValueUnit.pipe(
-            map(({ value, unit }) => {
-                const gotType = this._units.has(unit as any)
-                if (!gotType) {
-                    throw new InstrumentsError(
-                        `Unit ${unit} is not a valid unit of type ${this.unitType}`
-                    )
-                }
-                return new UnitValue<Unit>(unit as any, value, this.unitType)
-            })
-        )
-    }
-
-    parse = (input: `${number}${Unit}`) => {
-        const pUnitValue = this.parser
-        const result = pUnitValue.parse(input)
-        if (result.kind !== "OK") {
-            throw new InstrumentsError(`Failed to parse ${this.unitType}`, {
-                more: result.trace.toString()
-            })
-        }
-        return result.value
-    }
-
-    static make<const Unit extends string>(unitType: string, units: Set<Unit>) {
-        return new UnitParser<Unit>(unitType, units)
-    }
-}