@k8ts/instruments 0.11.4 → 0.12.0

package/src/expressions/workload/_user/index.ts

@@ -1,24 +0,0 @@
-export class Group {
-    constructor(
-        readonly id: number,
-        readonly name: string
-    ) {}
-}
-export class User {
-    constructor(
-        readonly id: number,
-        readonly name: string,
-        readonly group: Group
-    ) {}
-
-    static makeSync(id: number, name: string) {
-        return new User(id, name, new Group(id, name))
-    }
-
-    toDockerEnv(prefix = "P") {
-        return {
-            [`${prefix}UID`]: this.id,
-            [`${prefix}GID`]: this.group.id
-        }
-    }
-}

package/src/expressions/workload/cmd/cli-command.ts

@@ -1,99 +0,0 @@
-import { seq } from "doddle"
-import { defaultsDeep, merge } from "lodash"
-import { displayers } from "../../../utils/displayers"
-import {
-    Cli_Flag,
-    Cli_OptionValueTerm,
-    Cli_VerbatimTerm,
-    type Cli_sTermJoiner,
-    type CliTerm
-} from "./cli-term"
-import type { Cli_Record_ArgMap, Cli_sFlag } from "./types"
-
-export interface CliCommandBuilderOptions {
-    joiner: Cli_sTermJoiner
-}
-
-@displayers({
-    simple: s => s.string
-})
-export class CmdBuilder {
-    protected constructor(
-        readonly executable: string,
-        private readonly _terms: CliTerm[],
-        private readonly _options: CliCommandBuilderOptions
-    ) {}
-
-    private _withArgs(f: (args: CliTerm[]) => CliTerm[]) {
-        return new CmdBuilder(this.executable, f(this._terms), this._options)
-    }
-
-    private _withOptions(f: (options: CliCommandBuilderOptions) => CliCommandBuilderOptions) {
-        return new CmdBuilder(this.executable, this._terms, f(this._options))
-    }
-
-    flag(...flags: Cli_sFlag[]) {
-        const flagTerms = flags.map(flag => new Cli_Flag(flag))
-        return this._withArgs(terms => terms.concat(flagTerms))
-    }
-
-    verbatim(...values: string[]) {
-        const verbatimTerms = values.map(value => new Cli_VerbatimTerm(value))
-        return this._withArgs(terms => terms.concat(verbatimTerms))
-    }
-
-    option(args: Cli_Record_ArgMap) {
-        const map = new Map(Object.entries(args)) as Map<Cli_sFlag, string>
-        const optionTerms = seq(map)
-            .map(([key, value]) => {
-                let joiner: string | undefined
-                const lastChar = key.at(-1)
-                if (lastChar === "=") {
-                    joiner = "="
-                    key = key.slice(0, -1) as Cli_sFlag
-                } else if (lastChar === " ") {
-                    joiner = " "
-                    key = key.slice(0, -1) as Cli_sFlag
-                }
-                return new Cli_OptionValueTerm(key, joiner, value)
-            })
-            .toArray()
-            .pull()
-        return this._withArgs(terms => terms.concat(optionTerms))
-    }
-
-    joiner(joiner: Cli_sTermJoiner) {
-        return this._withOptions(options => merge({}, options, { joiner: joiner }))
-    }
-
-    toArray() {
-        const terms = seq(this._terms)
-            .filter(x => !x.isMissing)
-            .flatMap(term => {
-                return term.arr(this._options.joiner)
-            })
-            .toArray()
-            .pull()
-        if (this.executable !== "") {
-            terms.unshift(this.executable)
-        }
-        return terms
-    }
-
-    get string() {
-        return this.toArray().join(" ")
-    }
-
-    static make(executable: string, options: CliCommandBuilderOptions) {
-        return new CmdBuilder(executable, [], options)
-    }
-}
-
-const defaultOptions: CliCommandBuilderOptions = {
-    joiner: " "
-}
-
-export function Cmd(executable: string, options?: Partial<CliCommandBuilderOptions>) {
-    options = defaultsDeep({}, options, defaultOptions)
-    return CmdBuilder.make(executable, options as any)
-}

package/src/expressions/workload/cmd/index.ts

@@ -1,2 +0,0 @@
-export { Cmd, CmdBuilder } from "./cli-command"
-export type { Cli_Record_ArgMap, Cli_Value, Cli_sArgKey, Cli_sFlag } from "./types"

package/src/expressions/workload/cronjob/index.ts

@@ -1,166 +0,0 @@
-import { displayers } from "../../../utils/displayers"
-
-export type _SetObjectKey<Obj extends object, K extends keyof Obj, V> = {
-    [P in keyof Obj]: P extends K ? V : Obj[P]
-}
-
-declare const CRON_STRING: unique symbol
-
-function _convertStanzaElement(X: Cron.Element): string {
-    if (X === true) {
-        return "*"
-    }
-    if (X === false) {
-        return "0"
-    }
-    return `${X}`
-}
-@displayers({
-    simple(self) {
-        return self.string
-    }
-})
-export class CronStanza<R extends Cron.Record> {
-    constructor(private readonly record: R) {}
-
-    get tuple(): Cron.ToTuple<R> {
-        return [
-            this.record.minute,
-            this.record.hour,
-            this.record.dayOfMonth,
-            this.record.month,
-            this.record.dayOfWeek
-        ] as Cron.ToTuple<R>
-    }
-
-    get string() {
-        return this.tuple.map(_convertStanzaElement).join(" ") as Cron.String
-    }
-
-    minute<Minute extends Cron.Element>(
-        minute: Minute
-    ): CronStanza<_SetObjectKey<R, "minute", Minute>> {
-        return new CronStanza<_SetObjectKey<R, "minute", Minute>>({
-            ...this.record,
-            minute
-        } as any)
-    }
-
-    hour<Hour extends Cron.Element>(hour: Hour): CronStanza<_SetObjectKey<R, "hour", Hour>> {
-        return new CronStanza<_SetObjectKey<R, "hour", Hour>>({
-            ...this.record,
-            hour
-        } as any)
-    }
-
-    dayOfMonth<DayOfMonth extends Cron.Element>(
-        dayOfMonth: DayOfMonth
-    ): CronStanza<_SetObjectKey<R, "dayOfMonth", DayOfMonth>> {
-        return new CronStanza<_SetObjectKey<R, "dayOfMonth", DayOfMonth>>({
-            ...this.record,
-            dayOfMonth
-        } as any)
-    }
-
-    month<Month extends Cron.Element>(month: Month): CronStanza<_SetObjectKey<R, "month", Month>> {
-        return new CronStanza<_SetObjectKey<R, "month", Month>>({
-            ...this.record,
-            month
-        } as any)
-    }
-
-    dayOfWeek<DayOfWeek extends Cron.Element>(
-        dayOfWeek: DayOfWeek
-    ): CronStanza<_SetObjectKey<R, "dayOfWeek", DayOfWeek>> {
-        return new CronStanza<_SetObjectKey<R, "dayOfWeek", DayOfWeek>>({
-            ...this.record,
-            dayOfWeek
-        } as any)
-    }
-}
-
-export namespace Cron {
-    export type String = string & {
-        [CRON_STRING]: true
-    }
-    export type _CronDivisor = number
-    export type _CronBaseElement = `${number}` | `*`
-    export type _CronStep = `${_CronBaseElement}/${number}`
-    type _RangeElement = _CronBaseElement | _CronStep
-    export type _CronRange = `${_RangeElement}-${string}` & `${string}-${_RangeElement}`
-    type _ListElement = _CronBaseElement | _CronStep | _CronRange
-    export type List<Es extends _ListElement[] = _ListElement[]> = Es extends []
-        ? ""
-        : Es extends [infer E extends _ListElement, ...infer Rest extends _ListElement[]]
-          ? `${E},${List<Rest>}`
-          : never
-    export type Element = _CronBaseElement | _CronStep | _CronRange | List | true | number | false
-    export type Tuple<
-        Minute extends Element = Element,
-        Hour extends Element = Element,
-        DayOfMonth extends Element = Element,
-        Month extends Element = Element,
-        DayOfWeek extends Element = Element
-    > = [minute: Minute, hour: Hour, dayOfMonth: DayOfMonth, month: Month, dayOfWeek: DayOfWeek]
-
-    export type Record<
-        Minute extends Element = Element,
-        Hour extends Element = Element,
-        DayOfMonth extends Element = Element,
-        Month extends Element = Element,
-        DayOfWeek extends Element = Element
-    > = {
-        minute: Minute
-        hour: Hour
-        dayOfMonth: DayOfMonth
-        month: Month
-        dayOfWeek: DayOfWeek
-    }
-    export type ToTuple<T extends Record> = Tuple<
-        T["minute"],
-        T["hour"],
-        T["dayOfMonth"],
-        T["month"],
-        T["dayOfWeek"]
-    >
-    export type FromTuple<T extends Tuple> = {
-        minute: T[0]
-        hour: T[1]
-        dayOfMonth: T[2]
-        month: T[3]
-        dayOfWeek: T[4]
-    }
-
-    export function of<Tpl extends Tuple>(...items: Tpl): CronStanza<FromTuple<Tpl>> {
-        return new CronStanza<FromTuple<Tpl>>({
-            minute: items[0],
-            hour: items[1],
-            dayOfMonth: items[2],
-            month: items[3],
-            dayOfWeek: items[4]
-        })
-    }
-
-    export function from<R extends Record>(record: R): CronStanza<R> {
-        return new CronStanza<R>(record)
-    }
-
-    export const minutely = of(true, true, true, true, true)
-    export const hourly = of(0, true, true, true, true)
-    export const daily = of(0, 0, true, true, true)
-    export const weekly = of(0, 0, true, true, 0)
-    export const monthly = of(0, 0, 1, true, true)
-    export const yearly = of(0, 0, 1, 1, true)
-
-    export function parse(cron: string): CronStanza<Record> {
-        const parts = cron.split(" ")
-        if (parts.length !== 5) {
-            throw new Error(`Invalid cron string: ${cron}`)
-        }
-        return of(...(parts as any))
-    }
-
-    export function record<R extends Record>(record: R): CronStanza<R> {
-        return new CronStanza<R>(record)
-    }
-}

package/src/expressions/workload/image/family.ts

@@ -1,87 +0,0 @@
-import { displayers } from "../../../utils/displayers"
-
-export type JoinIfNotEmpty<A extends string, J extends string, B extends string> = A extends ""
-    ? B
-    : B extends ""
-      ? A
-      : `${A}${J}${B}`
-@displayers({
-    simple: s => s._url
-})
-export class ImageHost<Text extends string = string> {
-    private readonly _url: Text
-    constructor(source: Text) {
-        this._url = source
-    }
-
-    author<Author extends string>(name: Author) {
-        return new ImageAuthor<JoinIfNotEmpty<Text, "/", Author>>(this.toString(), name)
-    }
-
-    image<Image extends string>(name: Image) {
-        return new BaseImage<JoinIfNotEmpty<Text, "/", Image>>(this.toString(), name)
-    }
-
-    get [Symbol.toStringTag]() {
-        return this._url
-    }
-}
-@displayers({
-    simple: s => s._url
-})
-export class ImageAuthor<Text extends string = string> {
-    private readonly _url: Text
-    constructor(base: string, name: string) {
-        this._url = base === "" ? (name as Text) : ([base, name].join("/") as Text)
-    }
-
-    image<Image extends string>(name: Image) {
-        return new BaseImage<JoinIfNotEmpty<Text, "/", Image>>(this.toString(), name)
-    }
-}
-@displayers({
-    simple: s => {
-        if (!s._base) {
-            return s._name
-        }
-        return [s._base, s._name].join("/")
-    }
-})
-export class BaseImage<Text extends string = string> {
-    constructor(
-        private readonly _base: string,
-        private readonly _name: string
-    ) {}
-
-    tag<Tag extends string>(tag: Tag) {
-        return new TaggedImage<JoinIfNotEmpty<Text, ":", Tag>>(this, tag)
-    }
-}
-@displayers({
-    simple: s => {
-        const fam = s._family.toString()
-        if (s._tag === "") {
-            return fam
-        }
-        return [fam, s._tag].join(":")
-    }
-})
-export class TaggedImage<Text extends string = string> {
-    constructor(
-        private readonly _family: BaseImage<string>,
-        private readonly _tag: string
-    ) {}
-}
-
-export namespace Image {
-    export function author<Author extends string>(name: Author) {
-        return new ImageHost("").author(name)
-    }
-    export function name<Name extends `${string}/${string}`>(name: Name) {
-        return new ImageHost("").image(name)
-    }
-
-    export function host<Host extends string>(url: Host) {
-        return new ImageHost(url)
-    }
-}

package/src/utils/_string/index.ts

@@ -1,5 +0,0 @@
-export * from "./markers"
-export * from "./post-processor"
-export * from "./pretty-objects"
-export * from "./pretty-print"
-export * from "./super-script"

package/src/utils/_string/markers.ts

@@ -1,66 +0,0 @@
-import chalk from "chalk"
-
-const interchangeable = {
-    diamond: "◆",
-    star: "★",
-    four_shapes: "❖",
-    four_star: "✦",
-    star_circled_filled: "✪",
-
-    aster: "✱",
-    helm: "☸ ",
-    ball_circled: "◉",
-    lines_circled: "◍ ",
-    plus_circled: "⊕ ",
-
-    triangle_down: "▼",
-    dot_triangled: "◬",
-    diamond_diamonded: "◈",
-    circle_squared_filled: "◙",
-    triangle_filled_half: "◭",
-    heart_arrow: "❥",
-    bullet_squared_filled: "◘",
-    copyright: "©",
-    section: "§",
-    paragraph: "¶",
-    weird_circle: "¤",
-    euro: "€",
-    yen: "¥",
-    plus_filled: "✚",
-    mac_char: "⌘ "
-}
-
-const colors = [
-    chalk.redBright,
-    chalk.yellowBright,
-    chalk.blue,
-    chalk.magenta,
-    chalk.cyan,
-    chalk.blueBright
-]
-
-const numbered = Object.values(interchangeable)
-
-// We want to have symbols be as distinct as possible
-// that means we use each symbol with a different color
-
-// Instead of using all symbols of a single color, then all symbols of another color
-// We mix it up, so we only get repeat colors after all symbols have been used
-
-// we can get combinations of color + symbol like this:
-// symbol = i % symbols.length
-// color = (Math.floor(i / colors.length) + i)
-
-export function getMarkerForIndex(index: number) {
-    const clampedIndex = index % numbered.length
-    const multiplier = Math.floor(index / numbered.length)
-    const char = numbered[clampedIndex]
-    const color = colors[(multiplier + clampedIndex) % colors.length]
-    const colored = color(char)
-    return `${colored} `
-}
-
-export function getMarkerForExternal() {
-    const external = "∃"
-    return chalk.yellowBright(external)
-}

package/src/utils/_string/super-script.ts

@@ -1,17 +0,0 @@
-const digits = ["⁰", "¹", "²", "³", "⁴", "⁵", "⁶", "⁷", "⁸", "⁹"]
-
-export function toSuperScript(n: number): string {
-    if (n < 0) {
-        return "⁻" + toSuperScript(-n)
-    }
-    const num = []
-    while (n >= 0) {
-        const digit = n % 10
-        n = Math.floor(n / 10)
-        num.unshift(digits[digit])
-        if (n === 0) {
-            break
-        }
-    }
-    return num.join("")
-}

package/src/utils/tagged-template.ts

@@ -1,6 +0,0 @@
-export function createTaggedTemplate<DataSource_T>(f: (joined: string) => DataSource_T) {
-    return (tArgs: TemplateStringsArray, ...params: any[]) => {
-        const joined = String.raw(tArgs, ...params)
-        return f(joined)
-    }
-}