@k8ts/metadata 0.4.14 → 0.5.0

package/src/input/dict-input.ts

@@ -1,5 +1,6 @@
 import { ValueKey } from "../key"
 import type { Key } from "../key/types"
+import type { MetaLike } from "../meta"
 
 export namespace MetaInputParts {
     type Of<T extends string, V> = {
@@ -11,4 +12,8 @@ export namespace MetaInputParts {
     export type Input = Full & Heading
 }
 
-export type InputMeta = MetaInputParts.Input | undefined | Iterable<readonly [ValueKey, string]>
+export type InputMeta =
+    | MetaLike
+    | MetaInputParts.Input
+    | undefined
+    | Iterable<readonly [ValueKey, string]>

package/src/input/parse-dict.ts

@@ -1,24 +1,20 @@
-import { Map } from "immutable"
 import { isNullish } from "what-are-you"
 import { parseInnerKey, parseOuterKey } from "../key/parse-key"
-import { SectionKey, ValueKey } from "../key/repr"
+import { SectionKey } from "../key/repr"
 import { Meta } from "../meta"
 import type { InputMeta } from "./dict-input"
 
-export function parseMetaInput(input: InputMeta): Map<ValueKey, string> {
+export function parseMetaInput(input: InputMeta): Map<string, string> {
     if (input == null) {
-        return Map()
+        return new Map()
     }
-    if (Map.isMap(input)) {
-        return input as Map<ValueKey, string>
+    if (input instanceof Map) {
+        return new Map(input) as Map<string, string>
     }
     if (input instanceof Meta.Meta) {
-        return input["_dict"]
+        return new Map(input["_dict"] as Map<string, string>)
     }
-    if (input instanceof Meta.MutableMeta) {
-        return input["_meta"]["_dict"]
-    }
-    let map = Map<ValueKey, string>()
+    let map = new Map<string, string>()
     for (const [key, value] of Object.entries(input)) {
         const outer = parseOuterKey(key)
         if (isNullish(value)) {
@@ -37,13 +33,13 @@ export function parseMetaInput(input: InputMeta): Map<ValueKey, string> {
                 if (typeof vv !== "string") {
                     throw new Error(`Expected string value for inner key ${kk}`)
                 }
-                map = map.set(inner.section(outer), vv as string)
+                map.set(inner.section(outer).str, vv as string)
             }
         } else {
             if (typeof value !== "string") {
                 throw new Error(`Expected string value for key ${key}`)
             }
-            map = map.set(outer, value as string)
+            map.set(outer.str, value as string)
         }
     }
     return map

package/src/key/parse-key.ts

@@ -1,4 +1,4 @@
-import { anyCharOf, anyStringOf, digit, lower, string, upper } from "parjs"
+import { anyCharOf, anyStringOf, digit, letter, lower, string } from "parjs"
 import { many1, map, maybe, or, qthen, stringify, then, thenq } from "parjs/combinators"
 
 import { MetadataError } from "../error"
@@ -6,9 +6,11 @@ import { SectionKey, ValueKey } from "./repr"
 
 const cPrefix = anyCharOf("%^#")
 const cSection = string("/")
+export const normalChar = letter().pipe(or(digit())).expects("alphanumeric")
+const cDot = anyCharOf(".")
+
+const cExtra = anyCharOf(`-_`).pipe(or(cDot)).expects("'-', '_', or '.'")
 
-const cExtra = anyCharOf("-_.").expects("'-', '_', or '.'")
-export const normalChar = upper().pipe(or(lower(), digit())).expects("alphanumeric")
 const cNameChar = lower().pipe(or(digit())).pipe(or("-"))
 const cInterior = normalChar.pipe(or(cExtra)).expects("alphanumeric, '-', '_', or '.'")
 

package/src/key/repr.ts

@@ -1,9 +1,7 @@
-import { hash } from "immutable"
 import { MetadataError } from "../error"
 import { normalChar } from "./parse-key"
 interface ImmObject {
     equals(other: ImmObject): boolean
-    hashCode(): number
 }
 
 abstract class KeyType implements ImmObject {
@@ -11,9 +9,7 @@ abstract class KeyType implements ImmObject {
     equals(other: ImmObject): boolean {
         return this.constructor === other.constructor && this.toString() === other.toString()
     }
-    hashCode(): number {
-        return hash(this.toString())
-    }
+
     toString() {
         return this.str
     }

package/src/key/types.ts

@@ -8,19 +8,12 @@ export namespace Char {
 
     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}`
 }
 
 export namespace Key {
-    export type Section = `${Char.Normal}${string}${Char.Section}`
+    export type Section = `${string}${Char.Section}`
     export type Special = "name" | "namespace"
-    export type Value = (`${Char.Prefix.Custom}${string}` & `${string}${Char.Normal}`) | Special
+    export type Value = (`${Char.Prefix.Custom}${string}` & `${string}${string}`) | Special
 
     export type Key = Section | Value
 }

package/src/meta.ts

@@ -1,12 +1,18 @@
-import { Map, Set } from "immutable"
+import { seq } from "doddle"
 import { MetadataError } from "./error"
 import type { InputMeta, MetaInputParts } from "./input/dict-input"
 import { parseKey, parseMetaInput } from "./key"
 import { pNameValue } from "./key/parse-key"
 import { checkMetaString, ValueKey, type SectionKey } from "./key/repr"
-import { Key as Key_ } from "./key/types"
+import { Key } from "./key/types"
+import { orderMetaKeyedObject } from "./order-meta-keyed-object"
+import { equalsMap, toJS } from "./util"
 export type Meta = Meta.Meta
 export type MutableMeta = Meta.MutableMeta
+const MetaMarker = Symbol("k8ts.org/metadata")
+export interface MetaLike {
+    readonly [MetaMarker]: true
+}
 export namespace Meta {
     export function _checkNameValue(what: string, v: string) {
         if (!pNameValue.parse(v).isOk) {
@@ -14,73 +20,81 @@ export namespace Meta {
         }
         checkMetaString(what, v, 63)
     }
-    export function _checkValue(key: ValueKey, v: string) {
-        if (key.metaType === "label") {
-            checkMetaString(`value of ${key.str}`, v, 63)
-        } else if (key.metaType === "core") {
-            _checkNameValue(`value of ${key.str}`, v)
+    export function _checkValue(key: string, v: string) {
+        const parsed = parseKey(key)
+        if (!(parsed instanceof ValueKey)) {
+            throw new MetadataError(`Expected value key, got section key for ${key}`)
+        }
+        if (parsed.metaType === "label") {
+            checkMetaString(`value of ${key}`, v, 63)
+        } else if (parsed.metaType === "core") {
+            _checkNameValue(`value of ${key}`, v)
         }
     }
     export type Input = InputMeta
-    export import Key = Key_
-    export class Meta implements Iterable<[ValueKey, string]> {
-        constructor(private readonly _dict: Map<ValueKey, string>) {
+    export class Meta implements Iterable<[ValueKey, string]>, MetaLike {
+        readonly [MetaMarker] = true
+        constructor(private readonly _dict: Map<string, string>) {
             for (const [key, value] of _dict.entries()) {
                 _checkValue(key, value)
             }
         }
 
-        [Symbol.iterator]() {
-            return this._dict.entries()[Symbol.iterator]()
+        *[Symbol.iterator]() {
+            for (const entry of this._dict.entries()) {
+                yield [parseKey(entry[0]) as ValueKey, entry[1]] as [ValueKey, string]
+            }
         }
-        protected _create(raw: Map<ValueKey, string>) {
+        protected _create(raw: Map<string, string>) {
             return new Meta(raw)
         }
-        private _createWith(f: (raw: Map<ValueKey, string>) => Map<ValueKey, string>) {
-            return this._create(f(this._dict))
+        clone() {
+            return this._create(new Map(this._dict))
         }
-        add(key: Key.Value, value: string): Meta
+        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
+            const parsed = _pairToMap([a, b])
+            for (const [k, v] of parsed) {
+                if (this._dict.has(k)) {
+                    const prev = this._dict.get(k)
+                    throw new MetadataError(`Duplicate entry for ${k}, was ${prev} now ${v}`, {
+                        key: (k as any).str
                     })
-                }, parsed)
-                return newMap
-            })
+                }
+                this._dict.set(k, v)
+            }
+            return this
         }
 
         equals(other: Meta.Input) {
-            return this._dict.equals(make(other)._dict)
+            return equalsMap(this._dict, make(other)._dict)
         }
 
         section(key: string) {
-            return this._createWith(raw => {
-                return raw.mapKeys(k => k.section(key))
-            })
+            const newS = seq(this).map(([k, v]) => [k.section(key), v] as const)
+            return parseMetaInput(newS)
         }
 
-        overwrite(key: Key.Value, value: string): Meta
+        overwrite(key: Key.Value, value: string | undefined): 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)
-            })
+            const fromPair = _pairToMap([a, b])
+            for (const [k, v] of fromPair.entries()) {
+                this._dict.set(k, v)
+            }
+            return this
         }
 
         has<X extends Key.Value>(key: X) {
             const parsed = parseKey(key)
             if (parsed instanceof ValueKey) {
-                return this._dict.has(parsed)
+                return this._dict.has(key)
             } else {
                 return this._matchSectionKeys(parsed).size > 0
             }
@@ -88,7 +102,7 @@ export namespace Meta {
 
         get(key: Key.Value) {
             const parsed = parseKey(key)
-            const v = this._dict.get(parsed as ValueKey)
+            const v = this._dict.get(key)
             if (v === undefined) {
                 throw new MetadataError(`Key ${key} not found!`, { key })
             }
@@ -100,34 +114,44 @@ export namespace Meta {
             if (!(parsed instanceof ValueKey)) {
                 throw new MetadataError("Unexpected section key!", { key })
             }
-            return this._dict.get(parsed) ?? fallback
+            return this._dict.get(key) ?? fallback
         }
 
         private _matchSectionKeys(key: SectionKey) {
-            return this._dict.filter((_, k) => k.parent?.equals(key))
+            return seq(this)
+                .filter(([k, v]) => k.parent?.equals(key) ?? false)
+                .toMap(x => [x[0].str, x[1]] as const)
+                .pull()
         }
 
         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())
+            const parsed = keySpecs.map(parseKey)
+            const keyStrSet = new Set<string>()
+            for (const key of parsed) {
+                if (key instanceof ValueKey) {
+                    keyStrSet.add(key.str)
+                } else {
+                    const sectionKeys = this._matchSectionKeys(key)
+                    for (const k of sectionKeys.keys()) {
+                        keyStrSet.add(k)
                     }
                 }
-                return raw.filter((_, k) => keySet.has(k))
-            })
+            }
+            const out = new Map<string, string>()
+            for (const [k, v] of this._dict.entries()) {
+                if (keyStrSet.has(k)) out.set(k, v)
+            }
+            return this._create(out)
         }
 
         private _prefixed(prefix: string) {
-            return this._dict
-                .filter((_, k) => k._prefix === prefix)
-                .mapKeys(k => k.suffix)
-                .toObject()
+            const out: { [k: string]: string } = {}
+            for (const [k, v] of this) {
+                if (k._prefix === prefix) {
+                    out[k.suffix] = v
+                }
+            }
+            return orderMetaKeyedObject(out)
         }
 
         get labels() {
@@ -143,7 +167,14 @@ export namespace Meta {
         }
 
         get values() {
-            return this._dict.toJS()
+            return toJS(this._dict)
+        }
+
+        get keys(): ValueKey[] {
+            return seq(this)
+                .map(([k, v]) => k)
+                .toArray()
+                .pull()
         }
 
         get core() {
@@ -155,14 +186,25 @@ export namespace Meta {
         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))
+            const parsed = parseKey(a)
+            if (parsed instanceof ValueKey) {
+                this._dict.delete(parsed.str)
+                return this
+            }
+            if (b !== undefined) {
+                // remove specific key from section
+                for (const k of this.keys) {
+                    if (k.parent?.equals(parsed) && k.suffix === b) {
+                        this._dict.delete(k.str)
+                    }
                 }
-            })
+                return this
+            }
+            // remove entire section
+            for (const k of this.keys) {
+                if (k.parent?.equals(parsed)) this._dict.delete(k.str)
+            }
+            return this
         }
 
         expand() {
@@ -175,10 +217,6 @@ export namespace Meta {
                 annotations
             }
         }
-
-        toMutable() {
-            return new MutableMeta(this)
-        }
     }
 
     export function make(key: Key.Value, value: string): Meta
@@ -187,11 +225,9 @@ export namespace 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)
-        }
+    function _pairToObject(pair: [string | ValueKey, string | object] | [object]) {
+        let [key, value] = pair
+        key = key instanceof ValueKey ? key.str : key
         if (typeof key === "string") {
             return {
                 [key]: value as string
@@ -199,11 +235,8 @@ export namespace Meta {
         }
         return key
     }
-    function _pairToMap(pair: [string, string | object] | [object]) {
-        return parseMetaInput(_pairToObject(pair)).filter((v, k) => v != null)
-    }
-    export function makeMutable(input: InputMeta = {}) {
-        return make(input).toMutable()
+    function _pairToMap(pair: [string | ValueKey, string | object] | [object]) {
+        return parseMetaInput(_pairToObject(pair))
     }
 
     export function splat(...input: InputMeta[]) {
@@ -214,77 +247,15 @@ export namespace 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
+    export class MutableMeta extends Meta {
+        // MutableMeta is now just a direct extension of Meta so callers
+        // that expect MutableMeta keep working. The class body is empty
+        // because all mutation behavior lives on `Meta` itself.
+        constructor(...args: any[]) {
+            // Construct as a Meta instance. `Meta` constructor signature
+            // expects a Map<ValueKey, string> which callers provide when
+            // creating mutable instances.
+            super(args[0])
         }
     }
 }

package/src/order-meta-keyed-object.ts

@@ -0,0 +1,20 @@
+import { seq } from "doddle"
+
+function comparisonKey(key: string) {
+    const bySlash = key.split("/")
+    if (bySlash.length === 1) {
+        return key
+    }
+    if (bySlash.length > 2) {
+        throw new Error(`Invalid composed key ${key}, too many '/' characters.`)
+    }
+    const [dns, name] = bySlash
+    const dnsParts = dns.split(".").reverse()
+    return [...dnsParts, name].join("\uffff")
+}
+
+export function orderMetaKeyedObject(input: Record<string, string>): Record<string, any> {
+    const entries = seq(Object.entries(input)).orderBy(([key]) => comparisonKey(key))
+
+    return Object.fromEntries(entries)
+}

package/src/util.ts

@@ -0,0 +1,115 @@
+type Pair<X> = [X, X]
+export function mergeWith<K1, K2, V1, V2, V3>(
+    map1: Map<K1, V1>,
+    map2: Map<K2, V2>,
+    merger: (val1: V1, val2: V2, key: K1 | K2) => V3
+): Map<K1 | K2, V1 | V2 | V3> {
+    const result = new Map<K1 | K2, V1 | V2 | V3>(map1)
+    const allKeys = new Set<K1 | K2>([...map1.keys(), ...map2.keys()])
+    for (const k of allKeys) {
+        const val1 = map1.get(k as K1)
+        const val2 = map2.get(k as K2)
+        if (val1 !== undefined && val2 !== undefined) {
+            result.set(k, merger(val1, val2, k))
+        } else if (val2 !== undefined) {
+            result.set(k, val2)
+        }
+    }
+    return result
+}
+
+export function merge<K1, K2, V1, V2>(map1: Map<K1, V1>, map2: Map<K2, V2>): Map<K1 | K2, V1 | V2> {
+    return mergeWith(map1, map2, (_old, _new) => _new)
+}
+
+export function filterMap<K, V>(map: Map<K, V>, pred: (v: V, k: K) => boolean): Map<K, V> {
+    const out = new Map<K, V>()
+    for (const [k, v] of map.entries()) {
+        if (pred(v, k)) out.set(k, v)
+    }
+    return out
+}
+
+export function mapKeys<K, V, NK>(map: Map<K, V>, fn: (k: K) => NK): Map<NK, V> {
+    const out = new Map<NK, V>()
+    for (const [k, v] of map.entries()) {
+        out.set(fn(k), v)
+    }
+    return out
+}
+
+export function mapValues<K, V, NV>(map: Map<K, V>, fn: (v: V, k: K) => NV): Map<K, NV> {
+    const out = new Map<K, NV>()
+    for (const [k, v] of map.entries()) {
+        out.set(k, fn(v, k))
+    }
+    return out
+}
+
+export function toObject<K, V>(map: Map<K, V>): { [k: string]: V } {
+    const out: { [k: string]: V } = {}
+    for (const [k, v] of map.entries()) {
+        const key = (k as any)?.str ?? String(k)
+        out[key] = v
+    }
+    return out
+}
+
+export function toJS<K, V>(map: Map<K, V>): { [k: string]: V } {
+    return toObject(map)
+}
+
+export function equalsMap<K, V>(a: Map<K, V>, b: Map<K, V>): boolean {
+    if (a.size !== b.size) return false
+    for (const [ka, va] of a.entries()) {
+        let found = false
+        for (const [kb, vb] of b.entries()) {
+            const sa = (ka as any)?.str ?? ka
+            const sb = (kb as any)?.str ?? kb
+            if (sa === sb) {
+                found = true
+                if (va !== vb) return false
+                break
+            }
+        }
+        if (!found) return false
+    }
+    return true
+}
+
+export function mapFromObject<V>(obj: { [k: string]: V }): Map<string, V> {
+    const map = new Map<string, V>()
+    for (const k of Object.keys(obj)) {
+        map.set(k, obj[k])
+    }
+    return map
+}
+
+export function mapToObject<V>(map: Map<string, V>): { [k: string]: V } {
+    const obj: { [k: string]: V } = {}
+    for (const [k, v] of map.entries()) {
+        obj[k] = v
+    }
+    return obj
+}
+
+export type SourcedPropertyDescriptor = PropertyDescriptor & {
+    source: object
+}
+export function getDeepPropertyDescriptor(
+    obj: any,
+    propertyKey: string | symbol
+): SourcedPropertyDescriptor | undefined {
+    let current = obj
+    while (current) {
+        const descriptor = Object.getOwnPropertyDescriptor(current, propertyKey)
+        if (descriptor) {
+            return {
+                ...descriptor,
+                source: current
+            }
+        }
+        current = Object.getPrototypeOf(current)
+    }
+    return undefined
+}

package/dist/key/convert.d.ts

@@ -1,6 +0,0 @@
-import type { Map } from "immutable";
-import type { ValueKey } from "./repr";
-export declare function toObjectForm(map: Map<ValueKey, string>): {
-    [key: string]: string;
-};
-//# sourceMappingURL=convert.d.ts.map

package/dist/key/convert.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"convert.d.ts","sourceRoot":"","sources":["../../src/key/convert.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,WAAW,CAAA;AACpC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAA;AAEtC,wBAAgB,YAAY,CAAC,GAAG,EAAE,GAAG,CAAC,QAAQ,EAAE,MAAM,CAAC;;EAEtD"}

package/dist/key/convert.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toObjectForm = toObjectForm;
-function toObjectForm(map) {
-    return map.mapKeys(x => x.str).toObject();
-}
-//# sourceMappingURL=convert.js.map

package/dist/key/convert.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"convert.js","sourceRoot":"","sources":["../../src/key/convert.ts"],"names":[],"mappings":";;AAGA,oCAEC;AAFD,SAAgB,YAAY,CAAC,GAA0B;IACnD,OAAO,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,CAAA;AAC7C,CAAC"}

package/dist/mutable-meta.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=mutable-meta.d.ts.map