tering-serieuze-sdk 3.11.0 → 3.13.0

package/biome.json

@@ -0,0 +1,104 @@
+{
+    "$schema": "https://biomejs.dev/schemas/2.1.2/schema.json",
+    "vcs": { "enabled": true, "clientKind": "git", "useIgnoreFile": true },
+    "files": {
+        "includes": ["**/*.ts", "**/*.js", "**/*.mts", "**/*.json", "**/*.md", "!package*.json"]
+    },
+    "formatter": {
+        "enabled": true,
+        "indentStyle": "space",
+        "indentWidth": 4,
+        "lineWidth": 120
+    },
+    "linter": {
+        "enabled": true,
+        "rules": {
+            "recommended": true,
+            "complexity": {
+                "noExcessiveCognitiveComplexity": "error",
+                "noExcessiveNestedTestSuites": "error",
+                "noUselessStringConcat": "error"
+            },
+            "correctness": {
+                "noUndeclaredVariables": "error"
+            },
+            "nursery": {
+                "noAwaitInLoop": "error",
+                "noUnassignedVariables": "error",
+                "useNumericSeparators": "error",
+                "useObjectSpread": "error",
+                "useParseIntRadix": "error",
+                "useReadonlyClassProperties": "error"
+            },
+            "performance": {
+                "noBarrelFile": "off",
+                "noDelete": "error",
+                "noNamespaceImport": "error",
+                "noReExportAll": "off"
+            },
+            "style": {
+                "noCommonJs": "error",
+                "noInferrableTypes": "error",
+                "noNamespace": "error",
+                "noNestedTernary": "error",
+                "noNonNullAssertion": "error",
+                "noParameterAssign": "error",
+                "noSubstr": "error",
+                "noUnusedTemplateLiteral": "error",
+                "noUselessElse": "error",
+                "noYodaExpression": "error",
+                "useArrayLiterals": "error",
+                "useAsConstAssertion": "error",
+                "useBlockStatements": "error",
+                "useCollapsedIf": "error",
+                "useConsistentArrayType": "error",
+                "useConsistentBuiltinInstantiation": "error",
+                "useConst": "error",
+                "useDefaultParameterLast": "error",
+                "useDefaultSwitchClause": "error",
+                "useExplicitLengthCheck": "error",
+                "useForOf": "error",
+                "useImportType": "off",
+                "useLiteralEnumMembers": "error",
+                "useNodejsImportProtocol": "error",
+                "useNumberNamespace": "error",
+                "useShorthandAssign": "error",
+                "useShorthandFunctionType": "error",
+                "useThrowNewError": "error",
+                "useThrowOnlyError": "error",
+                "useTrimStartEnd": "error"
+            },
+            "suspicious": {
+                "noDuplicateTestHooks": "error",
+                "noEmptyBlockStatements": "error",
+                "noEvolvingTypes": "error",
+                "noExportsInTest": "error",
+                "noFocusedTests": "error",
+                "noMisplacedAssertion": "error",
+                "noSkippedTests": "error",
+                "noVar": "error",
+                "useAwait": "error",
+                "useErrorMessage": "error",
+                "useNumberToFixedDigitsArgument": "error"
+            }
+        },
+        "domains": {
+            "test": "all"
+        }
+    },
+    "javascript": {
+        "parser": {
+            "unsafeParameterDecoratorsEnabled": true
+        },
+        "formatter": {
+            "quoteStyle": "single"
+        }
+    },
+    "assist": {
+        "actions": {
+            "source": {
+                "organizeImports": "on"
+            }
+        }
+    }
+}

package/dist/index.mjs

@@ -5,6 +5,79 @@ var __publicField = (obj, key, value) => {
   return value;
 };
 
+// src/api/base.ts
+var BaseModule = class {
+  constructor(api, cache) {
+    this.api = api;
+    this.cache = cache;
+  }
+  getCache() {
+    return this.cache;
+  }
+  setCache(cache) {
+    this.cache = cache;
+  }
+};
+
+// src/api/auth.ts
+function parseJwt(token) {
+  let jsonPayload = "";
+  if (typeof Buffer !== "undefined") {
+    jsonPayload = Buffer.from(token.split(".")[1], "base64").toString();
+  } else {
+    const base64Url = token.split(".")[1];
+    const base64 = base64Url.replace(/-/g, "+").replace(/_/g, "/");
+    jsonPayload = decodeURIComponent(
+      window.atob(base64).split("").map((c) => "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2)).join("")
+    );
+  }
+  return JSON.parse(jsonPayload);
+}
+var _AuthModule = class extends BaseModule {
+  getToken() {
+    return process.env.TSS_TOKEN ? Promise.resolve(process.env.TSS_TOKEN) : this.cache.get(_AuthModule.cacheKey);
+  }
+  setToken(token, lifetime) {
+    return this.cache.set(_AuthModule.cacheKey, token, lifetime);
+  }
+  removeToken() {
+    return this.cache.remove(_AuthModule.cacheKey);
+  }
+  async getSessionId() {
+    const token = await this.getToken();
+    const { sessionId } = parseJwt(token ?? "");
+    return sessionId;
+  }
+  async removeSession(sessionId) {
+    const session = sessionId ?? await this.getSessionId();
+    await this.api.delete(`session/${session}`, { credentials: "include" });
+  }
+  async logout() {
+    await this.removeSession();
+    this.removeToken();
+  }
+  getRegistrationOptions(registrationToken) {
+    return this.api.get(`auth/registration-options/${registrationToken}`);
+  }
+  getAuthenticationOptions() {
+    return this.api.get("auth/authentication-options");
+  }
+  verifyRegistration(registrationToken, registrationResponse) {
+    return this.api.post(
+      `auth/verify-registration/${registrationToken}`,
+      registrationResponse,
+      { credentials: "include" }
+    );
+  }
+  verifyAuthentication(token, response) {
+    return this.api.post(`auth/verify-authentication/${token}`, response, {
+      credentials: "include"
+    });
+  }
+};
+var AuthModule = _AuthModule;
+__publicField(AuthModule, "cacheKey", "TSS-TOKEN");
+
 // node_modules/stack-trace/index.js
 function get(belowFn) {
   const oldLimit = Error.stackTraceLimit;
@@ -81,14 +154,14 @@ var AbstractCache = class {
 
 // src/cache/cookieCache.ts
 var CookieCache = class extends AbstractCache {
-  cacheOrGet(callbackWhenEmpty, key, lifetime) {
+  cacheOrGet() {
     throw new Error("Not implemented, use get() and set()");
   }
-  async get(key) {
+  get(key) {
     if (document.cookie.includes(`${key}=`)) {
-      return document.cookie.split(`${key}=`)[1]?.split(";")[0];
+      return Promise.resolve(document.cookie.split(`${key}=`)[1]?.split(";")[0]);
     }
-    return void 0;
+    return Promise.resolve(void 0);
   }
   set(key, value, lifetime) {
     const expires = lifetime ? new Date(Date.now() + lifetime).toUTCString() : "";
@@ -103,31 +176,34 @@ var CookieCache = class extends AbstractCache {
 };
 
 // src/cache/filesystemCache.ts
-import fs from "fs";
-import path from "path";
-import os from "os";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
 var FilesystemCache = class extends AbstractCache {
   initialized = false;
-  state = {};
+  state = /* @__PURE__ */ new Map();
   async cacheOrGet(callbackWhenEmpty, key, lifetime) {
-    key = key ?? this.getCacheKey();
-    const cachedValue = await this.get(key);
+    const usedKey = key ?? this.getCacheKey();
+    const cachedValue = await this.get(usedKey);
     if (cachedValue) {
       return cachedValue;
     }
     const result = await callbackWhenEmpty();
-    this.set(key, result, lifetime);
+    this.set(usedKey, result, lifetime);
     return result;
   }
-  async get(key) {
+  get(key) {
     if (!this.initialized) {
-      await this._initialize();
+      this._initialize();
     }
-    const expires = this.state[key]?.expiresAt;
-    if (Object.keys(this.state).includes(key) && (expires === void 0 || expires > Date.now())) {
-      return this.state[key].value;
+    const item = this.state.get(key);
+    if (item) {
+      const expires = item.expiresAt;
+      if (expires === void 0 || expires > Date.now()) {
+        return Promise.resolve(item.value);
+      }
     }
-    return void 0;
+    return Promise.resolve(void 0);
   }
   set(key, value, lifetime) {
     const expiresAt = lifetime ? Date.now() + lifetime : void 0;
@@ -135,15 +211,15 @@ var FilesystemCache = class extends AbstractCache {
     if (expiresAt) {
       content.expiresAt = expiresAt;
     }
-    this.state[key] = content;
+    this.state.set(key, content);
     this.writeState();
   }
   remove(key) {
-    delete this.state[key];
+    this.state.delete(key);
     this.writeState();
   }
   clear() {
-    this.state = {};
+    this.state.clear();
     if (fs.existsSync(this.getFilePath())) {
       fs.unlinkSync(this.getFilePath());
     }
@@ -154,39 +230,46 @@ var FilesystemCache = class extends AbstractCache {
   _initialize() {
     this.initialized = true;
     if (fs.existsSync(this.getFilePath())) {
-      this.state = JSON.parse(fs.readFileSync(this.getFilePath(), "utf8"));
+      try {
+        const fileContent = fs.readFileSync(this.getFilePath(), "utf8");
+        const parsed = JSON.parse(fileContent);
+        this.state = new Map(Object.entries(parsed));
+      } catch (_e) {
+        this.state = /* @__PURE__ */ new Map();
+      }
     }
   }
   writeState() {
     if (!fs.existsSync(path.dirname(this.getFilePath()))) {
-      fs.mkdirSync(path.dirname(this.getFilePath()));
+      fs.mkdirSync(path.dirname(this.getFilePath()), { recursive: true });
     }
-    fs.writeFileSync(this.getFilePath(), JSON.stringify(this.state));
+    const plainObject = Object.fromEntries(this.state);
+    fs.writeFileSync(this.getFilePath(), JSON.stringify(plainObject));
   }
 };
 
 // src/cache/nullCache.ts
 var NullCache = class extends AbstractCache {
-  cacheOrGet(callbackWhenEmpty, key, lifetime) {
+  cacheOrGet(callbackWhenEmpty) {
     return callbackWhenEmpty();
   }
-  async get(key) {
-    return void 0;
+  get() {
+    return Promise.resolve(void 0);
   }
-  set(key, value, lifetime) {
+  set() {
   }
-  remove(key) {
+  remove() {
   }
   clear() {
   }
 };
 
 // src/cache/onePasswordCache.ts
-import util from "util";
-import child_process from "child_process";
+import child_process from "node:child_process";
+import util from "node:util";
 var OnePasswordCache = class extends AbstractCache {
   asyncExec = util.promisify(child_process.exec);
-  cacheOrGet(callbackWhenEmpty, key, lifetime) {
+  cacheOrGet() {
     throw new Error("Not implemented, use get() and set()");
   }
   async get(key) {
@@ -197,14 +280,14 @@ var OnePasswordCache = class extends AbstractCache {
     }
     return JSON.parse(stdout).value;
   }
-  async set(key, value, lifetime) {
+  async set(key, value) {
     let action = `op item edit '${key}' 'credential=${value}'`;
     try {
-      const t = await this.get(key);
-    } catch (e) {
+      await this.get(key);
+    } catch (_e) {
       action = `op item create --category="API Credential" --title ${key} 'credential=${value}'`;
     }
-    const { stdout, stderr } = await this.asyncExec(action);
+    const { stderr } = await this.asyncExec(action);
     if (stderr) {
       console.log(stderr);
       throw new Error("ERROR");
@@ -217,88 +300,9 @@ var OnePasswordCache = class extends AbstractCache {
   }
 };
 
-// src/api/base.ts
-var BaseModule = class {
-  constructor(api, cache) {
-    this.api = api;
-    this.cache = cache;
-  }
-  getCache() {
-    return this.cache;
-  }
-  setCache(cache) {
-    this.cache = cache;
-  }
-};
-
-// src/api/auth.ts
-function parseJwt(token) {
-  let jsonPayload;
-  if (typeof Buffer !== "undefined") {
-    jsonPayload = Buffer.from(token.split(".")[1], "base64").toString();
-  } else {
-    const base64Url = token.split(".")[1];
-    const base64 = base64Url.replace(/-/g, "+").replace(/_/g, "/");
-    jsonPayload = decodeURIComponent(
-      window.atob(base64).split("").map(function(c) {
-        return "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2);
-      }).join("")
-    );
-  }
-  return JSON.parse(jsonPayload);
-}
-var _AuthModule = class extends BaseModule {
-  async getToken() {
-    return process.env.TSS_TOKEN ?? this.cache.get(_AuthModule.cacheKey);
-  }
-  async setToken(token, lifetime) {
-    return this.cache.set(_AuthModule.cacheKey, token, lifetime);
-  }
-  async setCode(code) {
-    const { accessToken } = await this.api.post(`auth/setCode?code=${code}`, {}, { credentials: "include" });
-    return accessToken;
-  }
-  async removeToken() {
-    return this.cache.remove(_AuthModule.cacheKey);
-  }
-  async getSessionId() {
-    const token = await this.getToken();
-    const { sessionId } = parseJwt(token ?? "");
-    return sessionId;
-  }
-  async removeSession(sessionId) {
-    const session = sessionId ?? await this.getSessionId();
-    await this.api.delete(`session/${session}`, { credentials: "include" });
-  }
-  async logout() {
-    await this.removeSession();
-    await this.removeToken();
-  }
-  async getRegistrationOptions(registrationToken) {
-    return this.api.get(`auth/registration-options/${registrationToken}`);
-  }
-  async getAuthenticationOptions() {
-    return this.api.get("auth/authentication-options");
-  }
-  async verifyRegistration(registrationToken, registrationResponse) {
-    return this.api.post(
-      `auth/verify-registration/${registrationToken}`,
-      registrationResponse,
-      { credentials: "include" }
-    );
-  }
-  async verifyAuthentication(token, response) {
-    return this.api.post(`auth/verify-authentication/${token}`, response, {
-      credentials: "include"
-    });
-  }
-};
-var AuthModule = _AuthModule;
-__publicField(AuthModule, "cacheKey", "TSS-TOKEN");
-
 // src/api/jingle.ts
 var JingleModule = class extends BaseModule {
-  async getGrouped() {
+  getGrouped() {
     return this.cache.cacheOrGet(
       () => {
         return this.api.get("jingle/grouped");
@@ -307,7 +311,7 @@ var JingleModule = class extends BaseModule {
       864e5 /* Day */
     );
   }
-  async getAll() {
+  getAll() {
     return this.cache.cacheOrGet(
       () => {
         return this.api.get("jingle");
@@ -320,18 +324,18 @@ var JingleModule = class extends BaseModule {
     const jingles = await this.getAll();
     return jingles.sort((a, b) => b.mtime - a.mtime).slice(0, 30);
   }
-  async play(playJingleDto) {
+  play(playJingleDto) {
     console.log(`Playing jingle ${playJingleDto.folder}/${playJingleDto.file}`);
     return this.api.post("jingle/play", playJingleDto);
   }
-  async getBigBrotherData() {
+  getBigBrotherData() {
     return this.api.get("jingle/bigbrother");
   }
   async find(query, jingles = []) {
-    jingles = jingles.length ? jingles : await this.getAll();
+    const items = jingles.length > 0 ? jingles : await this.getAll();
     const queryParts = query.split(" ");
-    const matches = jingles.filter(
-      (jingle) => queryParts.every((queryPart) => (jingle.folder + "/" + jingle.file).includes(queryPart))
+    const matches = items.filter(
+      (jingle) => queryParts.every((queryPart) => `${jingle.folder}/${jingle.file}`.includes(queryPart))
     );
     return matches.sort((a, b) => {
       const aScore = a.keywords.filter((keyword) => query.includes(keyword)).length;
@@ -343,26 +347,29 @@ var JingleModule = class extends BaseModule {
 
 // src/api/k8s.ts
 var K8sModule = class extends BaseModule {
+  getPods() {
+    return this.api.get("k8s");
+  }
   async deletePod(podName) {
-    return this.api.delete(`k8s/${podName}`);
+    return await this.api.delete(`k8s/${podName}`);
   }
 };
 
 // src/api/user.ts
 var UserModule = class extends BaseModule {
   async get(userId) {
-    return this.cache.cacheOrGet(() => {
+    return await this.cache.cacheOrGet(() => {
       const userIdParam = userId ? `/${userId}` : "";
       return this.api.get(`user${userIdParam}`);
     });
   }
   async getAll() {
-    return this.cache.cacheOrGet(() => {
+    return await this.cache.cacheOrGet(() => {
       return this.api.get("user/all");
     });
   }
   async setWindowState(setWindowStateDto) {
-    return this.api.putPossibleEmptyResponse("user/windowState", setWindowStateDto);
+    return await this.api.putPossibleEmptyResponse("user/windowState", setWindowStateDto);
   }
 };
 
@@ -411,7 +418,7 @@ var TssApi = class {
     let response;
     try {
       response = await fetch(fullUrl, config);
-    } catch (e) {
+    } catch (_e) {
       throw new ErrorResponse(503, "API erg dood");
     }
     if (response.status >= 400) {
@@ -420,7 +427,7 @@ var TssApi = class {
     }
     return response;
   }
-  async fetchPossibleEmptyResponse(method, url, dto, config = {}) {
+  fetchPossibleEmptyResponse(method, url, dto, config = {}) {
     return this.fetch(url, {
       method,
       ...config,
@@ -429,7 +436,7 @@ var TssApi = class {
   }
   async get(url) {
     const response = await this.fetch(url);
-    return response.json();
+    return await response.json();
   }
   async post(url, dto, config = {}) {
     const response = await this.fetchPossibleEmptyResponse("POST", url, dto, config);
@@ -438,7 +445,7 @@ var TssApi = class {
     }
     return await response.json();
   }
-  async postPossibleEmptyResponse(url, dto) {
+  postPossibleEmptyResponse(url, dto) {
     return this.fetchPossibleEmptyResponse("POST", url, dto);
   }
   async put(url, dto) {
@@ -448,10 +455,10 @@ var TssApi = class {
     }
     return await response.json();
   }
-  async putPossibleEmptyResponse(url, dto) {
+  putPossibleEmptyResponse(url, dto) {
     return this.fetchPossibleEmptyResponse("PUT", url, dto);
   }
-  async delete(url, config = {}) {
+  delete(url, config = {}) {
     return this.fetch(url, {
       method: "DELETE",
       ...config