@k8ts/metadata 0.10.2 → 0.11.0

package/src/input/key/string-types.ts

@@ -0,0 +1,15 @@
+export type Metadata_Key_sPrefix_Label = "%"
+export type Metadata_Key_sPrefix_Annotation = "^"
+export type Metadata_Key_sPrefix_Comment = "#"
+export type Metadata_Key_sPrefix =
+    | Metadata_Key_sPrefix_Label
+    | Metadata_Key_sPrefix_Annotation
+    | Metadata_Key_sPrefix_Comment
+export type Metadata_Key_sSuffix_Domain = "/"
+
+export type Metadata_Key_sDomain = `${string}${Metadata_Key_sSuffix_Domain}`
+export type Metadata_Key_sPrefixed = `${Metadata_Key_sPrefix}${string}`
+export type Metadata_Key_sValue = Metadata_Key_sPrefixed
+export type NotPrefixed<T extends string> = [T] extends [Metadata_Key_sPrefixed]
+    ? `𝗣𝗿𝗲𝗳𝗶𝘅𝗲𝘀 𝗮𝗿𝗲 𝗶𝗹𝗹𝗲𝗴𝗮𝗹 𝗶𝗻 𝘁𝗵𝗲 𝗱𝗼𝗺𝗮𝗶𝗻 𝘀𝗲𝗰𝘁𝗶𝗼𝗻`
+    : Metadata_Key_sDomain

package/src/input/parse-dict.ts

@@ -1,28 +1,38 @@
 import { isNullish } from "what-are-you"
-import { parseInnerKey, parseOuterKey } from "../key/parse-key"
-import { DomainPrefix } from "../key/repr"
-import { Meta } from "../meta"
-import type { InputMeta } from "./dict-input"
+import { K8tsMetadataError } from "../error"
+import { Metadata } from "../meta"
+import type { Metadata_Input } from "./dict-input"
+import { Metadata_Key_Domain } from "./key/domain-prefix"
+import { parseInnerKey, parseOuterKey } from "./key/parse-key"
+import type { Metadata_Key_sValue } from "./key/string-types"
 
-export function parseMetaInput(input: InputMeta): Map<string, string> {
+export function parseMetaInput(input: Metadata_Input): Map<Metadata_Key_sValue, string> {
     if (input == null) {
         return new Map()
     }
     if (input instanceof Map) {
-        return new Map(input) as Map<string, string>
+        return new Map(input) as Map<Metadata_Key_sValue, string>
     }
-    if (input instanceof Meta.Meta) {
-        return new Map(input["_dict"] as Map<string, string>)
+    if (Symbol.iterator in Object(input)) {
+        let map = new Map<Metadata_Key_sValue, string>()
+        for (const item of input as Iterable<readonly [string, string]>) {
+            const [key, value] = item
+            map.set(key as any, value)
+        }
+        return map
+    }
+    if (input instanceof Metadata) {
+        return new Map(input["_dict"])
     }
-    let map = new Map<string, string>()
+    let map = new Map<Metadata_Key_sValue, string>()
     for (const [key, value] of Object.entries(input)) {
         const outer = parseOuterKey(key)
         if (isNullish(value)) {
             continue
         }
-        if (outer instanceof DomainPrefix) {
+        if (outer instanceof Metadata_Key_Domain) {
             if (typeof value !== "object") {
-                throw new Error(`Expected object for section key ${key}`)
+                throw new K8tsMetadataError(`Expected object for section key ${key}`)
             }
             for (const [kk, vv] of Object.entries(value)) {
                 if (isNullish(vv)) {
@@ -31,13 +41,13 @@ export function parseMetaInput(input: InputMeta): Map<string, string> {
                 const inner = parseInnerKey(kk)
 
                 if (typeof vv !== "string") {
-                    throw new Error(`Expected string value for inner key ${kk}`)
+                    throw new K8tsMetadataError(`Expected string value for inner key ${kk}`)
                 }
                 map.set(inner.domain(outer).str, vv as string)
             }
         } else {
             if (typeof value !== "string") {
-                throw new Error(`Expected string value for key ${key}`)
+                throw new K8tsMetadataError(`Expected string value for key ${key}`)
             }
             map.set(outer.str, value as string)
         }