chore(typechecking): typecheck /lib

src/components/cc-tile-instances/cc-tile-instances.js

@@ -93,15 +93,25 @@ export class CcTileInstances extends LitElement {
     if (this._lastRunningCount !== runningInstancesCount) {
       this.updateComplete.then(() => {
         // This is not supported in Safari yet, but it's purely decorative so let's keep it like that
-        animate(this.shadowRoot, '.instances[data-type=running] .count-bubble', ...QUICK_SHRINK);
+        animate(
+          this.shadowRoot,
+          '.instances[data-type=running] .count-bubble',
+          QUICK_SHRINK.keyframes,
+          QUICK_SHRINK.options,
+        );
         this._lastRunningCount = runningInstancesCount;
       });
     }
 
     if (this._lastDeployingCount !== deployingInstancesCount) {
       this.updateComplete.then(() => {
         // This is not supported in Safari yet, but it's purely decorative so let's keep it like that
-        animate(this.shadowRoot, '.instances[data-type=deploying] .count-bubble', ...QUICK_SHRINK);
+        animate(
+          this.shadowRoot,
+          '.instances[data-type=deploying] .count-bubble',
+          QUICK_SHRINK.keyframes,
+          QUICK_SHRINK.options,
+        );
         this._lastDeployingCount = deployingInstancesCount;
       });
     }

src/components/common.types.d.ts

@@ -63,7 +63,7 @@ interface InvoiceAmount {
 export interface Invoice {
   downloadUrl: string;
   emissionDate: string;
-  invoiceHtml: string;
+  invoiceHtml?: string;
   number: string;
   paymentUrl: string;
   status: InvoiceStatusType;
@@ -214,3 +214,15 @@ interface EnvVarEditorStateLoaded {
 /* endregion */
 
 export type NotificationIntent = 'info' | 'success' | 'warning' | 'danger';
+
+export interface Notification {
+  message: string | Node;
+  title?: string;
+  intent: NotificationIntent;
+  options?: NotificationOptions;
+}
+
+export interface NotificationOptions {
+  timeout?: number;
+  closeable?: boolean;
+}

src/lib/animate.js

@@ -1,11 +1,18 @@
+/**
+ *
+ * @param {ShadowRoot} shadowRoot
+ * @param {string} selector
+ * @param {Array<Keyframe> | PropertyIndexedKeyframes} keyframes
+ * @param {number | KeyframeAnimationOptions} options
+ */
 export function animate(shadowRoot, selector, keyframes, options) {
   Array.from(shadowRoot.querySelectorAll(selector)).forEach((element) => element.animate(keyframes, options));
 }
 
-export const QUICK_SHRINK = [
-  [{ transform: 'scale(1)' }, { transform: 'scale(0.9)' }, { transform: 'scale(1)' }],
-  {
+export const QUICK_SHRINK = {
+  keyframes: [{ transform: 'scale(1)' }, { transform: 'scale(0.9)' }, { transform: 'scale(1)' }],
+  options: {
     duration: 200,
     easing: 'ease-in-out',
   },
-];
+};

src/lib/ansi/ansi-palette-analyser.js

@@ -1,19 +1,26 @@
 import { getContrastRatio, hexToRgb, isDark } from '../color.js';
 
-const colors = ['red', 'green', 'yellow', 'blue', 'magenta', 'cyan'];
+/**
+ * @typedef {import('./ansi.types.js').AnsiPalette} AnsiPalette
+ * @typedef {keyof AnsiPalette} ColorsType
+ */
+
+/** @type {Array<ColorsType>} */
+const COLORS = ['red', 'green', 'yellow', 'blue', 'magenta', 'cyan'];
 
 /**
- *
  * @param {AnsiPalette} palette
  */
 export function analyzePalette(palette) {
   const background = hexToRgb(palette.background);
+  /** @type {Array<ColorsType>} */
   const colorsToTest = getColorsToTest(isDark(background));
 
   const colorsCount = colorsToTest.length;
   let ratioSum = 0;
   let compliantCount = 0;
 
+  /** @type {Partial<Record<ColorsType, { ratio: number, compliant: boolean }>>} */
   const contrasts = {};
 
   colorsToTest.forEach((colorName) => {
@@ -34,8 +41,13 @@ export function analyzePalette(palette) {
   };
 }
 
+/**
+ * @param {boolean} isDarkPalette
+ * @return {Array<ColorsType>}
+ */
 function getColorsToTest(isDarkPalette) {
-  const result = [...colors, isDarkPalette ? 'white' : 'black'];
+  const result = [...COLORS, isDarkPalette ? 'white' : 'black'];
 
+  // @ts-ignore
   return [...result, ...result.map((c) => `bright-${c}`)];
 }

src/lib/ansi/ansi.js

@@ -2,6 +2,10 @@ import ansiRegEx from 'ansi-regex';
 import { css, html, unsafeCSS } from 'lit';
 import { MemoryCache } from '../memory-cache.js';
 
+/**
+ * @typedef {import('./ansi.types.js').AnsiPart} AnsiPart
+ */
+
 /** @type {AnsiParser} - Lazy loaded parser */
 let ansiParser;
 
@@ -134,7 +138,7 @@ ANSI_COLORS.forEach((style) => {
 
 /**
  * Remove all ANSI escape codes from the given text.
- * @param text
+ * @param {string} text
  * @return {string}
  */
 export function stripAnsi(text) {
@@ -145,14 +149,16 @@ export function stripAnsi(text) {
  * Converts the given text into Lit template according to the ANSI escape codes found in text.
  *
  * When using this, don't forget to include the `ansiPaletteStyle` CSS rules to a parent element. (see ./ansi-palette-style)
+ *
+ * @param {string} text
  */
 export function ansiToLit(text) {
   if (ansiParser == null) {
     ansiParser = new AnsiParser();
   }
 
   const tokens = ansiParser.parse(text);
-  return tokens.map((token, i) => {
+  return tokens.map((token) => {
     if (token.styles.length === 0) {
       return token.text;
     }
@@ -232,6 +238,11 @@ class AnsiParser {
     /** @type {Map<string, Set<string>>} */
     const commonEscapes = new Map();
 
+    /**
+     * @param {string} name
+     * @param {string} code
+     * @param {Array<string>} escapes
+     */
     const handleCode = (name, code, escapes) => {
       const ansiCode = toAnsi(code);
       this.codeToStyle.set(ansiCode, name);
@@ -261,15 +272,15 @@ class AnsiParser {
   }
 
   /**
-   * @param str
+   * @param {string} str
    * @return {Array<AnsiPart>}
    */
   parse(str) {
     return this.cache.get(str);
   }
 
   /**
-   * @param str
+   * @param {string} str
    * @return {Array<AnsiPart>}
    */
   _doParse(str) {
@@ -329,17 +340,30 @@ function addToIndexMap(map, key, value) {
   map.get(key).add(value);
 }
 
+/**
+ * @param {Array<T>} arr
+ * @param {T} val
+ * @template T
+ */
 function removeElm(arr, val) {
   const i = arr.indexOf(val);
   if (i >= 0) {
     arr.splice(i, 1);
   }
 }
 
+/**
+ * @param {string|number} code
+ * @return {string}
+ */
 function toAnsi(code) {
   return `\u001b[${code}m`;
 }
 
+/**
+ * @param {string} ansiCode
+ * @return {string}
+ */
 function fromAnsi(ansiCode) {
   return ansiCode.slice(2, ansiCode.length - 1);
 }