@k8ts/metadata 0.1.0

package/src/key/repr.ts

@@ -0,0 +1,72 @@
+import { hash } from "immutable"
+interface ImmObject {
+    equals(other: ImmObject): boolean
+    hashCode(): number
+}
+abstract class KeyType implements ImmObject {
+    abstract get str(): string
+    equals(other: ImmObject): boolean {
+        return this.constructor === other.constructor && this.toString() === other.toString()
+    }
+    hashCode(): number {
+        return hash(this.toString())
+    }
+    toString() {
+        return this.str
+    }
+}
+
+export class ValueKey extends KeyType {
+    type = "full" as const
+    constructor(
+        readonly _prefix: string,
+        readonly _section: string | undefined,
+        readonly _name: string
+    ) {
+        super()
+    }
+
+    get suffix() {
+        const parts = []
+        if (this._section) {
+            parts.push(this._section)
+            if (!this._section.endsWith("/")) {
+                parts.push("/")
+            }
+        }
+        parts.push(this._name)
+        return parts.join("")
+    }
+
+    get str() {
+        return [this._prefix, this.suffix].join("")
+    }
+
+    get parent() {
+        if (this._section == null) {
+            return null
+        }
+        return new SectionKey(this._section)
+    }
+
+    section(section: string | SectionKey) {
+        section = section instanceof SectionKey ? section.str : section
+        if (this._section) {
+            throw new Error("Already has a section")
+        }
+        return new ValueKey(this._prefix, section, this._name)
+    }
+}
+
+export class SectionKey extends KeyType {
+    type = "heading" as const
+    constructor(readonly _section: string) {
+        super()
+    }
+
+    get str() {
+        return [this._section].join("")
+    }
+}
+
+export type SomeKey = ValueKey | SectionKey

package/src/key/types.ts

@@ -0,0 +1,27 @@
+export namespace Char {
+    export namespace Prefix {
+        export type Label = "%"
+        export type Annotation = "^"
+        export type Comment = "#"
+        export type Custom = `${Label | Annotation | Comment}`
+    }
+
+    export type Section = "/"
+    export const Section = "/"
+
+    export type Lower =
+        `${"a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z"}`
+    export type Upper = Uppercase<Lower>
+    export type Digit = `${"0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"}`
+    export type Extra = "-" | "_" | "."
+    export type Normal = `${Lower | Digit | Extra | Upper}`
+}
+
+export namespace Key {
+    export type Section = `${Char.Normal}${string}${Char.Section}`
+    export type Special = "name" | "namespace"
+    export type Value = `${Char.Prefix.Custom}${string}${Char.Normal}` | Special
+
+    export type Key = Section | Value
+}
+export type Key = Key.Key

package/src/meta.ts

@@ -0,0 +1,275 @@
+import { Map, Set } from "immutable"
+import { MetadataError } from "./error"
+import type { InputMeta, MetaInputParts } from "./input/dict-input"
+import { parseKey, parseMetaInput } from "./key"
+import { ValueKey, type SectionKey } from "./key/repr"
+import { Key as Key_ } from "./key/types"
+export type Meta = Meta.Meta
+export type MutableMeta = Meta.MutableMeta
+export namespace Meta {
+    export type Input = InputMeta
+    export import Key = Key_
+    export class Meta implements Iterable<[ValueKey, string]> {
+        constructor(private readonly _dict: Map<ValueKey, string>) {
+            const a = _dict
+            const aaa = 1
+        }
+
+        [Symbol.iterator]() {
+            return this._dict.entries()[Symbol.iterator]()
+        }
+        protected _create(raw: Map<ValueKey, string>) {
+            return new Meta(raw)
+        }
+        private _createWith(f: (raw: Map<ValueKey, string>) => Map<ValueKey, string>) {
+            return this._create(f(this._dict))
+        }
+        add(key: Key.Value, value: string): Meta
+        add(key: Key.Section, value: MetaInputParts.Nested): Meta
+        add(input: InputMeta): Meta
+        add(a: any, b?: any) {
+            return this._createWith(raw => {
+                const parsed = _pairToMap([a, b])
+                const newMap = raw.mergeWith((prev, cur, key) => {
+                    throw new MetadataError(`Duplicate entry for ${key}, was ${prev} now ${cur}`, {
+                        key: key.str
+                    })
+                }, parsed)
+                return newMap
+            })
+        }
+
+        equals(other: Meta.Input) {
+            return this._dict.equals(make(other)._dict)
+        }
+
+        section(key: string) {
+            return this._createWith(raw => {
+                return raw.mapKeys(k => k.section(key))
+            })
+        }
+
+        overwrite(key: Key.Value, value: string): Meta
+        overwrite(key: Key.Section, value: MetaInputParts.Nested): Meta
+        overwrite(input?: InputMeta): Meta
+        overwrite(a?: any, b?: any) {
+            if (a === undefined) {
+                return this
+            }
+            return this._createWith(raw => {
+                const fromPair = _pairToMap([a, b])
+                return raw.merge(fromPair)
+            })
+        }
+
+        has<X extends Key.Value>(key: X) {
+            const parsed = parseKey(key)
+            if (parsed instanceof ValueKey) {
+                return this._dict.has(parsed)
+            } else {
+                return this._matchSectionKeys(parsed).size > 0
+            }
+        }
+
+        get(key: Key.Value) {
+            const parsed = parseKey(key)
+            const v = this._dict.get(parsed as ValueKey)
+            if (v === undefined) {
+                throw new MetadataError(`Key ${key} not found!`, { key })
+            }
+            return v
+        }
+
+        tryGet(key: Key.Value, fallback?: string) {
+            const parsed = parseKey(key)
+            if (!(parsed instanceof ValueKey)) {
+                throw new MetadataError("Unexpected section key!", { key })
+            }
+            return this._dict.get(parsed) ?? fallback
+        }
+
+        private _matchSectionKeys(key: SectionKey) {
+            return this._dict.filter((_, k) => k.parent?.equals(key))
+        }
+
+        pick(...keySpecs: Key.Key[]) {
+            return this._createWith(raw => {
+                const parsed = keySpecs.map(parseKey)
+                let keySet = Set()
+                for (const key of parsed) {
+                    if (key instanceof ValueKey) {
+                        keySet = keySet.add(key)
+                    } else {
+                        const sectionKeys = this._matchSectionKeys(key)
+                        keySet = keySet.union(sectionKeys.keySeq())
+                    }
+                }
+                return raw.filter((_, k) => keySet.has(k))
+            })
+        }
+
+        private _prefixed(prefix: string) {
+            return this._dict
+                .filter((_, k) => k._prefix === prefix)
+                .mapKeys(k => k.suffix)
+                .toObject()
+        }
+
+        get labels() {
+            return this._prefixed("%")
+        }
+
+        get annotations() {
+            return this._prefixed("^")
+        }
+
+        get comments() {
+            return this._prefixed("#")
+        }
+
+        get values() {
+            return this._dict.toJS()
+        }
+
+        get core() {
+            return this._prefixed("") as {
+                [key in Key.Special]?: string
+            }
+        }
+        remove(key: Key.Value): this
+        remove(ns: Key.Section, key: string): this
+        remove(ns: Key.Section): this
+        remove(a: any, b?: any) {
+            return this._createWith(raw => {
+                const parsed = parseKey(a)
+                if (parsed instanceof ValueKey) {
+                    return raw.delete(parsed)
+                } else {
+                    return raw.filter((_, k) => !k.parent?.equals(parsed))
+                }
+            })
+        }
+
+        expand() {
+            const labels = this.labels
+            const annotations = this.annotations
+            const core = this.core
+            return {
+                ...core,
+                labels,
+                annotations
+            }
+        }
+
+        toMutable() {
+            return new MutableMeta(this)
+        }
+    }
+
+    export function make(key: Key.Value, value: string): Meta
+    export function make(key: Key.Section, value: MetaInputParts.Nested): Meta
+    export function make(input?: InputMeta): Meta
+    export function make(a?: any, b?: any) {
+        return new Meta(_pairToMap([a, b]))
+    }
+    function _pairToObject(pair: [string, string | object] | [object]) {
+        const [key, value] = pair
+        if (key instanceof Meta) {
+            return Map(key)
+        }
+        if (typeof key === "string") {
+            return {
+                [key]: value as string
+            }
+        }
+        return key
+    }
+    function _pairToMap(pair: [string, string | object] | [object]) {
+        return parseMetaInput(_pairToObject(pair))
+    }
+    export function makeMutable(input: InputMeta = {}) {
+        return make(input).toMutable()
+    }
+
+    export function splat(...input: InputMeta[]) {
+        return input.map(make).reduce((acc, meta) => acc.add(meta), make())
+    }
+
+    export function is(value: any): value is Meta {
+        return value instanceof Meta
+    }
+
+    export class MutableMeta {
+        constructor(private _meta: Meta) {}
+
+        add(key: Key.Value, value: string): this
+        add(key: Key.Section, value: MetaInputParts.Nested): this
+        add(input: InputMeta): this
+        add(a: any, b?: any) {
+            this._meta = this._meta.add(a, b)
+            return this
+        }
+
+        remove(key: Key.Value): this
+        remove(ns: Key.Section, key: string): this
+        remove(ns: Key.Section): this
+        remove(a: any, b?: any) {
+            this._meta = this._meta.remove(a, b)
+            return this
+        }
+
+        overwrite(key: Key.Value, value: string): this
+        overwrite(key: Key.Section, value: MetaInputParts.Nested): this
+        overwrite(input?: InputMeta): this
+        overwrite(a?: any, b?: any) {
+            this._meta = this._meta.overwrite(a, b)
+            return this
+        }
+        equals(other: Meta.Input) {
+            return this._meta.equals(other)
+        }
+        get(key: Key.Value) {
+            return this._meta.get(key)
+        }
+
+        tryGet(key: Key.Value, fallback?: string) {
+            return this._meta.tryGet(key, fallback)
+        }
+
+        has(key: Key.Value) {
+            return this._meta.has(key)
+        }
+
+        pick(...keySpecs: Key.Key[]) {
+            const newMeta = this._meta.pick(...keySpecs)
+            return new MutableMeta(newMeta)
+        }
+
+        toMutable() {
+            return new MutableMeta(this._meta)
+        }
+
+        section(key: string) {
+            return new MutableMeta(this._meta.section(key))
+        }
+        get labels() {
+            return this._meta.labels
+        }
+
+        get annotations() {
+            return this._meta.annotations
+        }
+
+        get comments() {
+            return this._meta.comments
+        }
+
+        get core() {
+            return this._meta.core
+        }
+
+        toImmutable() {
+            return this._meta
+        }
+    }
+}

package/src/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": ".",
+    "noEmit": false,
+    "outDir": "../dist",
+    "tsBuildInfoFile": "../dist/src.tsbuildinfo"
+  },
+  "include": ["**/*.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "references": [
+    {
+      "path": "./src/tsconfig.json"
+    },
+    {
+      "path": "./test/tsconfig.json"
+    }
+  ],
+  "compilerOptions": {
+    "composite": true,
+    "noEmit": true
+  },
+  "files": []
+}