Not tested

Split by Space Reverse Join Sort lines (ascending, case sensitive)
PathWithoutBracketsSingularized

.gitignore

@@ -264,3 +264,42 @@ __pycache__/
 type-script-helper-1.1.6.vsix
 type-script-helper-1.1.7.vsix
 type-script-helper-1.1.8.vsix
+
+.kanbn
+*.exe
+*.pdb
+
+.vscode/helper/**
+
+type-script-helper/src/Card.js
+type-script-helper/src/Card.js.map
+type-script-helper/src/ColumnsToCardsWebviewViewProvider.js
+type-script-helper/src/ColumnsToCardsWebviewViewProvider.js.map
+type-script-helper/src/constants.js
+type-script-helper/src/constants.js.map
+type-script-helper/src/extension.js
+type-script-helper/src/extension.js.map
+type-script-helper/src/getNonce.js
+type-script-helper/src/getNonce.js.map
+type-script-helper/src/H2HexColor.js
+type-script-helper/src/H2HexColor.js.map
+type-script-helper/src/H2NoCheckboxes.js
+type-script-helper/src/H2NoCheckboxes.js.map
+type-script-helper/src/H2WithCheckboxes.js
+type-script-helper/src/H2WithCheckboxes.js.map
+type-script-helper/src/kanbanHelper.js
+type-script-helper/src/kanbanHelper.js.map
+type-script-helper/src/LineNumber.js
+type-script-helper/src/LineNumber.js.map
+type-script-helper/src/markdownHelper.js
+type-script-helper/src/markdownHelper.js.map
+type-script-helper/src/PostMessage.js
+type-script-helper/src/PostMessage.js.map
+type-script-helper/src/promiseLinesHelper.js
+type-script-helper/src/promiseLinesHelper.js.map
+type-script-helper/src/readOnlyLinesHelper.js
+type-script-helper/src/readOnlyLinesHelper.js.map
+type-script-helper/src/replaceLinesHelper.js
+type-script-helper/src/replaceLinesHelper.js.map
+type-script-helper/src/WebViewPanel.js
+type-script-helper/src/WebViewPanel.js.map

.vscode/settings.json

@@ -1,5 +1,27 @@
 {
-    "cSpell.words": [
-        "VSIX"
-    ]
+  "[markdown]": {
+    "editor.wordWrap": "off"
+  },
+  "cSpell.words": [
+    "Infineon",
+    "initialise",
+    "Kanban",
+    "Phares",
+    "VSIX",
+    "Weightest",
+    "WSJF"
+  ],
+  "files.eol": "\n",
+  "files.exclude": {
+    "**/dist": false,
+    "**/node_modules": true,
+    "**/out": false
+  },
+  "files.watcherExclude": {
+    "**/node_modules": true
+  },
+  "search.exclude": {
+    "**/dist": true,
+    "**/out": true
+  }
 }

package-lock.json

@@ -1,6 +0,0 @@
-{
-  "name": "YO-VSCode",
-  "lockfileVersion": 2,
-  "requires": true,
-  "packages": {}
-}

type-script-helper/.eslintrc.json

@@ -0,0 +1,24 @@
+{
+    "root": true,
+    "parser": "@typescript-eslint/parser",
+    "parserOptions": {
+        "ecmaVersion": 6,
+        "sourceType": "module"
+    },
+    "plugins": [
+        "@typescript-eslint"
+    ],
+    "rules": {
+        "@typescript-eslint/naming-convention": "warn",
+        "@typescript-eslint/semi": "warn",
+        "curly": "warn",
+        "eqeqeq": "warn",
+        "no-throw-literal": "warn",
+        "semi": "off"
+    },
+    "ignorePatterns": [
+        "out",
+        "dist",
+        "**/*.d.ts"
+    ]
+}

type-script-helper/.gitignore

@@ -1,4 +1,7 @@
-out
-node_modules
 .vscode-test/
+.vscode/helper/**
 *.vsix
+dist
+node_modules
+out
+src/*.js*

type-script-helper/.vscode/extensions.json

@@ -1,7 +1,5 @@
 {
-	// See http://go.microsoft.com/fwlink/?LinkId=827846
-	// for the documentation about the extensions.json format
-	"recommendations": [
-		"ms-vscode.vscode-typescript-tslint-plugin"
-	]
-}
+  // See http://go.microsoft.com/fwlink/?LinkId=827846
+  // for the documentation about the extensions.json format
+  "recommendations": ["dbaeumer.vscode-eslint", "amodio.tsl-problem-matcher"]
+}

type-script-helper/.vscode/launch.json

@@ -9,28 +9,21 @@
 			"name": "Run Extension",
 			"type": "extensionHost",
 			"request": "launch",
-			"runtimeExecutable": "${execPath}",
 			"args": [
 				"--extensionDevelopmentPath=${workspaceFolder}"
 			],
 			"outFiles": [
-				"${workspaceFolder}/out/**/*.js"
-			],
-			"preLaunchTask": "${defaultBuildTask}"
+				"${workspaceFolder}/dist/**/*.js"
+			]
 		},
 		{
-			"name": "Extension Tests",
-			"type": "extensionHost",
+			"type": "node",
 			"request": "launch",
-			"runtimeExecutable": "${execPath}",
-			"args": [
-				"--extensionDevelopmentPath=${workspaceFolder}",
-				"--extensionTestsPath=${workspaceFolder}/out/test/suite/index"
-			],
+			"name": "Launch Program",
+			"program": "${workspaceFolder}/src/extension.ts",
 			"outFiles": [
-				"${workspaceFolder}/out/test/**/*.js"
-			],
-			"preLaunchTask": "${defaultBuildTask}"
+				"${workspaceFolder}/out/**/*.js"
+			]
 		}
 	]
-}
+}

type-script-helper/.vscode/mklink.md

@@ -0,0 +1,11 @@
+---
+type: "note"
+created: "2023-10-20T03:53:13.742Z"
+updated: "2023-10-20T04:00:37.259Z"
+---
+
+# mklink
+
+```bash
+mklink /J "L:\Git\YO-VSCode\type-script-helper\net8.0\win-x64\publish" "L:\DevOps\Mesa_FI\File-Folder-Helper\bin\Release\net8.0\win-x64\publish"
+```

type-script-helper/.vscode/settings.json

@@ -1,11 +1,29 @@
-// Place your settings in this file to overwrite default and user settings.
 {
-    "files.exclude": {
-        "out": false // set this to true to hide the "out" folder with the compiled JS files
-    },
-    "search.exclude": {
-        "out": true // set this to false to include "out" folder in search results
-    },
-    // Turn off tsc task auto detection since we have the necessary tasks as npm scripts
-    "typescript.tsc.autoDetect": "off"
+  "[markdown]": {
+    "editor.wordWrap": "off"
+  },
+  "cSpell.words": [
+    "Infineon",
+    "initialise",
+    "Kanban",
+    "Phares",
+    "signalr",
+    "VSIX",
+    "Weightest",
+    "WSJF"
+  ],
+  "files.eol": "\n",
+  "files.exclude": {
+    "**/dist": false,
+    "**/node_modules": true,
+    "**/out": false
+  },
+  "files.watcherExclude": {
+    "**/node_modules": true
+  },
+  "explorer.sortOrder": "default",
+  "search.exclude": {
+    "**/dist": true,
+    "**/out": true
+  }
 }

type-script-helper/.vscode/tasks.json

@@ -1,20 +1,63 @@
-// See https://go.microsoft.com/fwlink/?LinkId=733558
-// for the documentation about the tasks.json format
 {
-	"version": "2.0.0",
-	"tasks": [
-		{
-			"type": "npm",
-			"script": "watch",
-			"problemMatcher": "$tsc-watch",
-			"isBackground": true,
-			"presentation": {
-				"reveal": "never"
-			},
-			"group": {
-				"kind": "build",
-				"isDefault": true
-			}
-		}
-	]
-}
+    "tasks": [
+        {
+            "type": "npm",
+            "script": "tsc-build",
+            "group": "build",
+            "problemMatcher": [],
+            "label": "npm: tsc-build",
+            "detail": "tsc"
+        },
+        {
+            "type": "npm",
+            "script": "tsc-clean",
+            "problemMatcher": [],
+            "label": "npm: tsc-clean",
+            "detail": "tsc --build --clean"
+        },
+        {
+            "type": "npm",
+            "script": "vscode:package",
+            "problemMatcher": [],
+            "label": "npm: vscode:package",
+            "detail": "node node_modules/@vscode/vsce/vsce package"
+        },
+        {
+            "type": "npm",
+            "script": "vscode:login",
+            "problemMatcher": [],
+            "label": "npm: vscode:login",
+            "detail": "node node_modules/@vscode/vsce/vsce login Infineon-Technologies-AG-Mesa-FI"
+        },
+        {
+            "type": "npm",
+            "script": "vscode:ls-publishers",
+            "problemMatcher": [],
+            "label": "npm: vscode:ls-publishers",
+            "detail": "node node_modules/@vscode/vsce/vsce ls-publishers"
+        },
+        {
+            "type": "npm",
+            "script": "vscode:publish",
+            "problemMatcher": [],
+            "label": "npm: vscode:publish",
+            "detail": "node node_modules/@vscode/vsce/vsce publish"
+        },
+        {
+            "type": "npm",
+            "script": "watch",
+            "group": "build",
+            "problemMatcher": [],
+            "label": "npm: watch",
+            "detail": "concurrently \"rollup -c -w\" \"webpack --watch --config ./build/node-extension.webpack.config.js\""
+        },
+        {
+            "type": "npm",
+            "script": "webpack",
+            "problemMatcher": [],
+            "label": "npm: webpack",
+            "detail": "webpack --config ./build/node-extension.webpack.config.js"
+        }
+    ],
+    "version": "2.0.0"
+}

type-script-helper/.vscodeignore

@@ -1,10 +1,14 @@
-.vscode/**
-.vscode-test/**
-out/test/**
-src/**
 .gitignore
-vsc-extension-quickstart.md
-**/tsconfig.json
-**/tslint.json
+.vscode-test/**
+.vscode/**
+.yarnrc
+**/.eslintrc.json
 **/*.map
-**/*.ts
+**/*.ts
+**/tsconfig.json
+build/**
+node_modules/**
+src/**
+webviews/**
+vsc-extension-quickstart.md
+webpack.config.js

type-script-helper/CHANGELOG.md

@@ -1,9 +0,0 @@
-# Change Log
-
-All notable changes to the "type-script-helper" extension will be documented in this file.
-
-Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how to structure this file.
-
-## [Unreleased]
-
-- Initial release

type-script-helper/LICENSE.md

@@ -0,0 +1,27 @@
+---
+type: "note"
+created: "2022-03-10T21:18:17.054Z"
+updated: "2022-03-10T21:18:17.054Z"
+---
+
+# LICENSE
+
+Copyright (c) Twitter Inc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

type-script-helper/README.md

@@ -1,6 +1,10 @@
-# type-script-helper README
+---
+type: "read-me"
+created: "2023-09-30T01:47:18.241Z"
+updated: "2023-09-30T01:47:18.242Z"
+---
 
-Helpers
+# type-script-helper README
 
 ## Features
 
@@ -8,7 +12,28 @@ See Contributions tab
 
 ## Requirements
 
-None
+```bash
+# https://code.visualstudio.com/api/get-started/your-first-extension
+npm install -g yo generator-code
+
+yo code
+
+# ? What type of extension do you want to create? New Extension (TypeScript)
+# ? What's the name of your extension? HelloWorld
+### Press <Enter> to choose default for all options below ###
+
+# ? What's the identifier of your extension? hello-world
+# ? What's the description of your extension? LEAVE BLANK
+# ? Initialize a git repository? Yes
+# ? Bundle the source code with webpack? No (should be yes?)
+# ? Which package manager to use? npm
+
+# ? Do you want to open the new folder with Visual Studio Code? Open with `code`
+
+npm install -g @vscode/vsce
+
+vsce package
+```
 
 ## Extension Settings
 
@@ -20,85 +45,188 @@ None
 
 ## Release Notes
 
-npm install -g vsce
-
-npm install typescript --save-dev
-
-L:
-
-cd "L:\GitHub\YO-VSCode\type-script-helper"
-
-npm install typescript
-
-npx tsc
-
-L:
-
-cd "L:\GitHub\YO-VSCode\type-script-helper"
-
-yo code
-
-Type Script Helper
-
-(type-script-helper)
-
-Modify .package
-
-Add publisher
-
-cd "L:\GitHub\YO-VSCode\type-script-helper"
-
-vsce package
-
-F1
-Extensions: Install from VSIX
-
-## 1.0.0
-
-Initial release of ...
-
-## 1.0.1
-
-Fixed issue in replace function
-https://stackoverflow.com/questions/37197311/in-typescript-string-replace-only-replaces-first-occurrence-of-matched-string
-Added split(' group by ').join('\r\n GROUP BY ').
-
-## 1.1.0
------------------------------------------------------------------------------------------------------------
-
-Working with Markdown
-
-For more information
-
 ## 1.2.4
 -----------------------------------------------------------------------------------------------------------
 
-Search Google
+- Search Google
 
 ## 1.2.8
 -----------------------------------------------------------------------------------------------------------
 
-Search Google (Read Only Lines Helper)
+- Search Google (Read Only Lines Helper)
 
 ## 1.2.9, 1.3.0, 1.3.1, 1.3.2
 -----------------------------------------------------------------------------------------------------------
 
-Quick Fix - Camel Case Properties
-Quick Fix -  CS0108 (Data Annotations)
-Quick Fix - Proper Case Properties
-Quick Fix - Public (Expression Body)
+- Quick Fix - Camel Case Properties
+- Quick Fix - CS0108 (Data Annotations)
+- Quick Fix - Proper Case Properties
+- Quick Fix - Public (Expression Body)
 
 ## 1.3.3, 1.3.4
 -----------------------------------------------------------------------------------------------------------
 
-Quick Fix - Instance Field to Calisthenics
+- Quick Fix - Instance Field to Calisthenics
 
 ## 1.3.5, 1.3.6, 1.3.7, 1.3.8, 1.3.9, 1.3.10, 1.3.11
 -----------------------------------------------------------------------------------------------------------
 
-Code Generator - Quick Pick {promiseLinesHelper.codeGeneratorQuickPick}
-Open in New Window {open-in-new-window.open}
-Learned npm install will do similar to nuget restore
-Learned npm audit fix
-Learned npm audit fix --force
-Learned npm run compile will do similar to build
+- Code Generator - Quick Pick {promiseLinesHelper.codeGeneratorQuickPick}
+- Open in New Window {open-in-new-window.open}
+- Learned npm install will do similar to nuget restore
+- Learned npm audit fix
+- Learned npm audit fix --force
+- Learned npm run compile will do similar to build
+- Quick Fix - Instance Field to Calisthenics
+
+## 1.3.12, 1.3.13, 1.3.14
+-----------------------------------------------------------------------------------------------------------
+
+- Split by Space Reverse Join Sort lines (ascending, case sensitive)
+- PathWithoutBracketsSingularized
+
+## 1.3.15
+-----------------------------------------------------------------------------------------------------------
+
+- Distinct list
+
+## 1.4.1
+-----------------------------------------------------------------------------------------------------------
+
+- new yo code template
+
+## 1.4.2
+-----------------------------------------------------------------------------------------------------------
+
+- Insert date time
+
+## 1.4.3
+-----------------------------------------------------------------------------------------------------------
+
+- Moved Insert date time
+- Transform to Popper Case
+
+## 1.4.4
+-----------------------------------------------------------------------------------------------------------
+
+- Transform to Param Case
+
+## 1.5.1
+-----------------------------------------------------------------------------------------------------------
+
+- columns-to-cards-webview-view-provider
+- file-folder-helper-exe
+- clickable list
+
+## 1.5.2
+-----------------------------------------------------------------------------------------------------------
+
+- file-folder-helper-exe net8.0
+
+## 1.5.3
+-----------------------------------------------------------------------------------------------------------
+
+- Updated File-Folder-Helper ccea8de8cf49343dd4190a77ac755d233bb4e528
+
+## 1.6.0
+-----------------------------------------------------------------------------------------------------------
+
+- Updated File-Folder-Helper 4e3f06bb44b7e85ba40a5e589e6ca871cbdbfb3e
+
+## 1.6.1
+-----------------------------------------------------------------------------------------------------------
+
+- Updated File-Folder-Helper 299aa19d538bcfd5e06e4743a5a05f6d62960a80
+- code --install-extension D:\Tmp\phares\type-script-helper-1.6.1.vsix
+- code-insiders --install-extension D:\Tmp\phares\type-script-helper-1.6.1.vsix
+
+## 1.6.2
+-----------------------------------------------------------------------------------------------------------
+
+- Updated File-Folder-Helper 47e6b85c218f994216fb35d44906850a790c36d0
+- Open with Text Editor Kanban
+
+## 1.6.4 Fri Aug 02 2024 13:07:24 GMT-0700 (Mountain Standard Time)
+-----------------------------------------------------------------------------------------------------------
+
+- Wrap directory in quotes
+
+## 1.7.0 Fri Aug 30 2024 11:13:09 GMT-0700 (Mountain Standard Time)
+-----------------------------------------------------------------------------------------------------------
+
+- Copy Syntax In Light Theme
+- [Copy-Syntax-in-Light](https://github.com/Ahmed-Adel-Morsi/Copy-Syntax-in-Light)
+
+## 1.8.0 Wed Nov 06 2024 06:03:59 GMT-0700 (Mountain Standard Time)
+-----------------------------------------------------------------------------------------------------------
+
+- Change insert date to include epoch seconds and ticks *
+
+## 1.9.0 1735586943373 = 638711837433730000 = Mon Dec 30 2024 12:29:02 GMT-0700 (Mountain Standard Time)
+-----------------------------------------------------------------------------------------------------------
+
+- Insert All Extensions (Not Disabled)
+
+## 1.110.0 1735689397890 = 638712861978900000 = Tue Dec 31 2024 16:56:37 GMT-0700 (Mountain Standard Time)
+-----------------------------------------------------------------------------------------------------------
+
+- Open Sub-Kanban in New Window
+
+## 1.111.0 1736196204601 = 638717930046010000 = 2025-0.Winter = Mon Jan 06 2025 13:43:24 GMT-0700 (Mountain Standard Time)
+-----------------------------------------------------------------------------------------------------------
+
+- Added season to insert date
+- Removed
+    - kanban.refreshBoth
+    - kanban.refreshSidebar
+    - kanban.refreshWebview
+    - kanban.debugReload
+    - columns-to-cards-webview-view-provider-view
+
+- Open Sub-Kanban in New Window
+
+## 1.111.1 1738206291411 = 638738030914110000 = 2025-0.Winter = Wed Jan 29 2025 20:04:50 GMT-0700 (Mountain Standard Time)
+-----------------------------------------------------------------------------------------------------------
+
+- Changed trigger for code-insiders
+
+## 1.112.0 1738349146299 = 638739459462990000 = 2025-0.Winter = Fri Jan 31 2025 11:45:45 GMT-0700 (Mountain Standard Time)
+-----------------------------------------------------------------------------------------------------------
+
+- Added Cost of Delay (CoD)
+
+## 1.113.0 1739287994496 = 638748847944960000 = 2025-0.Winter = Tue Feb 11 2025 08:33:14 GMT-0700 (Mountain Standard Time)
+-----------------------------------------------------------------------------------------------------------
+
+- Add Code Insiders lines when not present
+
+## 1.114.0 1739295723637 = 638748925236370000 = 2025-0.Winter = Tue Feb 11 2025 10:42:03 GMT-0700 (Mountain Standard Time)
+-----------------------------------------------------------------------------------------------------------
+
+- infineon-mes-mike-phares
+
+## 1.115.0 1739295727065 = 638748925270650000 = 2025-0.Winter = Tue Feb 11 2025 10:42:06 GMT-0700 (Mountain Standard Time)
+-----------------------------------------------------------------------------------------------------------
+
+- Infineon-Technologies-AG-Mesa-FI
+
+## 1.116.0 1740441381597 = 638760381815970000 = 2025-0.Winter = Mon Feb 24 2025 16:56:21 GMT-0700 (Mountain Standard Time)
+-----------------------------------------------------------------------------------------------------------
+
+- Calculator
+- Explorer Sort Order
+
+## 1.117.0 1740671831803 = 638762686318030000 = 2025-0.Winter = Thu Feb 27 2025 08:57:11 GMT-0700 (Mountain Standard Time)
+-----------------------------------------------------------------------------------------------------------
+
+- Close active after opening Sub-Kanban when directory found
+
+## 1.118.0 1741303103654 = 638768999036540000 = 2025-0.Winter = Thu Mar 06 2025 16:18:23 GMT-0700 (Mountain Standard Time)
+-----------------------------------------------------------------------------------------------------------
+
+- Add search page for Backlog
+
+## 1.119.0 1742607894338 = 638782046943380000 = 2025-1.Spring = Fri Mar 21 2025 18:44:53 GMT-0700 (Mountain Standard Time)
+-----------------------------------------------------------------------------------------------------------
+
+- Generic File-Folder-Helper call

type-script-helper/build/node-extension.webpack.config.js

@@ -0,0 +1,41 @@
+//@ts-check
+
+'use strict';
+
+const path = require('path');
+
+/**@type {import('webpack').Configuration}*/
+const config = {
+  target: 'node', // vscode extensions run in a Node.js-context 📖 -> https://webpack.js.org/configuration/node/
+	mode: 'none', // this leaves the source code as close as possible to the original (when packaging we set this to 'production')
+
+  entry: './src/extension.ts', // the entry point of this extension, 📖 -> https://webpack.js.org/configuration/entry-context/
+  output: {
+    // the bundle is stored in the 'dist' folder (check package.json), 📖 -> https://webpack.js.org/configuration/output/
+    path: path.resolve(__dirname, '..', 'dist'),
+    filename: 'extension.js',
+    libraryTarget: 'commonjs2'
+  },
+  devtool: 'nosources-source-map',
+  externals: {
+    vscode: 'commonjs vscode' // the vscode-module is created on-the-fly and must be excluded. Add other modules that cannot be webpack'ed, 📖 -> https://webpack.js.org/configuration/externals/
+  },
+  resolve: {
+    // support reading TypeScript and JavaScript files, 📖 -> https://github.com/TypeStrong/ts-loader
+    extensions: ['.ts', '.js']
+  },
+  module: {
+    rules: [
+      {
+        test: /\.ts$/,
+        exclude: /node_modules/,
+        use: [
+          {
+            loader: 'ts-loader'
+          }
+        ]
+      }
+    ]
+  }
+};
+module.exports = config;

type-script-helper/media/checklist.svg

@@ -0,0 +1 @@
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path fill-rule="evenodd" clip-rule="evenodd" d="M3.75 4.48h-.71L2 3.43l.71-.7.69.68L4.81 2l.71.71-1.77 1.77zM6.99 3h8v1h-8V3zm0 3h8v1h-8V6zm8 3h-8v1h8V9zm-8 3h8v1h-8v-1zM3.04 7.48h.71l1.77-1.77-.71-.7L3.4 6.42l-.69-.69-.71.71 1.04 1.04zm.71 3.01h-.71L2 9.45l.71-.71.69.69 1.41-1.42.71.71-1.77 1.77zm-.71 3.01h.71l1.77-1.77-.71-.71-1.41 1.42-.69-.69-.71.7 1.04 1.05z"/></svg>

type-script-helper/media/cod.css

@@ -0,0 +1,37 @@
+#HeaderGridDiv,
+#DetailsGridDiv {
+    font-size: 12px;
+    min-width: 1200px;
+    max-width: 1200px;
+}
+
+#HeaderGrid {
+    font-family: monospace;
+    margin-top: 60px;
+}
+
+#HeaderGrid tr td {
+    max-width: 200px;
+    padding: 5px;
+}
+
+#AllGrid {
+    font-family: monospace;
+}
+
+.navbar-brand {
+    min-width: 1200px;
+    background-color: whitesmoke;
+}
+
+tr:nth-of-type(odd) {
+    background-color: #eee;
+}
+
+#AllTextarea {
+    font-family: monospace;
+}
+
+#th-span {
+    margin-right: 500px;
+}

type-script-helper/media/cost-of-delay.js

@@ -0,0 +1,50 @@
+$(document).ready(function () {
+    const fromHtml = true;
+    const username = _webviewUsername;
+    const machineId = _webviewMachineId;
+    const baseUri = 'https://eaf-dev.mes.infineon.com';
+    const apiUrl = 'https://eaf-dev.mes.infineon.com/api/v1/ado/';
+    const windowLocationHRef = window.location.href + '?site=' + _webviewSite + 'view=' + _webviewView;
+    const signalRUrl = baseUri + '/signalr';
+    const workItems = {
+        a: baseUri + '/markdown/bugs-features-with-parents.json?v=2025-01-22-10-49',
+        b: baseUri + '/markdown/{[]}.json?v=2025-01-22-10-49'
+    };
+    const b = {
+        page: 'business',
+        description: 'Value',
+        th: 'Business Value',
+        span: 'What is the relative value to the Customer or business?<br>• Do our users prefer this over that?<br>• What is the revenue impact on our business?<br>• Is there a potential penalty or other negative effects if we delay?'
+    };
+    const r = {
+        page: 'risk',
+        description: 'Risk',
+        th: 'Risk Reduction and/or Opportunity Enablement',
+        span: 'What else does this do for our business?<br>• Reduce the risk of this or future delivery?<br>• Is there value in the information we will receive?<br>• Enable new business opportunities?'
+    };
+    const t = {
+        page: 'time',
+        description: 'Critical',
+        th: 'Time Criticality',
+        span: 'How does user/business value decay over time?<br>• Is there a fixed deadline?<br>• Will they wait for us or move to another Solution?<br>• What is the current effect on Customer satisfaction?'
+    };
+    const c = {
+        page: 'cod',
+        description: 'CoD',
+        th: 'Cost of Delay (CoD)',
+        span: "Cost of Delay (CoD) is the money lost by delaying or not doing a job for a specific time. It's a measure of the economic value of a job over time."
+    };
+    const e = {
+        page: 'effort',
+        description: 'Effort',
+        th: 'Effort',
+        span: 'Effort'
+    };
+    const w = {
+        page: 'wsjf',
+        description: 'WSJF',
+        th: 'Weightest Shortest Job First calculation (WSJF)',
+        span: 'Weightest Shortest Job First calculation (see @SCALE formula)'
+    };
+    initIndex(fromHtml, username, machineId, windowLocationHRef, workItems, b, r, t, c, e, w, apiUrl, signalRUrl);
+});

type-script-helper/media/main.js

@@ -0,0 +1,7 @@
+// This script will be run within the webview itself
+// It cannot access the main VS Code APIs directly.
+(function () {
+  const vscode = acquireVsCodeApi();
+
+  console.log("hello there from javascript");
+})();

type-script-helper/media/reset.css

@@ -0,0 +1,30 @@
+html {
+  box-sizing: border-box;
+  font-size: 13px;
+}
+
+*,
+*:before,
+*:after {
+  box-sizing: inherit;
+}
+
+body,
+h1,
+h2,
+h3,
+h4,
+h5,
+h6,
+p,
+ol,
+ul {
+  margin: 0;
+  padding: 0;
+  font-weight: normal;
+}
+
+img {
+  max-width: 100%;
+  height: auto;
+}

type-script-helper/media/vscode.css

@@ -0,0 +1,91 @@
+:root {
+  --container-paddding: 20px;
+  --input-padding-vertical: 6px;
+  --input-padding-horizontal: 4px;
+  --input-margin-vertical: 4px;
+  --input-margin-horizontal: 0;
+}
+
+body {
+  padding: 0 var(--container-paddding);
+  color: var(--vscode-foreground);
+  font-size: var(--vscode-font-size);
+  font-weight: var(--vscode-font-weight);
+  font-family: var(--vscode-font-family);
+  background-color: var(--vscode-editor-background);
+}
+
+ol,
+ul {
+  padding-left: var(--container-paddding);
+}
+
+body > *,
+form > * {
+  margin-block-start: var(--input-margin-vertical);
+  margin-block-end: var(--input-margin-vertical);
+}
+
+*:focus {
+  outline-color: var(--vscode-focusBorder) !important;
+}
+
+a {
+  color: var(--vscode-textLink-foreground);
+}
+
+a:hover,
+a:active {
+  color: var(--vscode-textLink-activeForeground);
+}
+
+code {
+  font-size: var(--vscode-editor-font-size);
+  font-family: var(--vscode-editor-font-family);
+}
+
+button {
+  border: none;
+  padding: var(--input-padding-vertical) var(--input-padding-horizontal);
+  width: 100%;
+  text-align: center;
+  outline: 1px solid transparent;
+  outline-offset: 2px !important;
+  color: var(--vscode-button-foreground);
+  background: var(--vscode-button-background);
+}
+
+button:hover {
+  cursor: pointer;
+  background: var(--vscode-button-hoverBackground);
+}
+
+button:focus {
+  outline-color: var(--vscode-focusBorder);
+}
+
+button.secondary {
+  color: var(--vscode-button-secondaryForeground);
+  background: var(--vscode-button-secondaryBackground);
+}
+
+button.secondary:hover {
+  background: var(--vscode-button-secondaryHoverBackground);
+}
+
+input:not([type="checkbox"]),
+textarea {
+  display: block;
+  width: 100%;
+  border: none;
+  font-family: var(--vscode-font-family);
+  padding: var(--input-padding-vertical) var(--input-padding-horizontal);
+  color: var(--vscode-input-foreground);
+  outline-color: var(--vscode-input-border);
+  background-color: var(--vscode-input-background);
+}
+
+input::placeholder,
+textarea::placeholder {
+  color: var(--vscode-input-placeholderForeground);
+}

type-script-helper/package.json

@@ -1,157 +1,342 @@
 {
-    "name": "type-script-helper",
-    "displayName": "Type Script Helper",
-    "description": "Helper for VS Code in TypeScript",
-    "publisher": "IFX",
-    "repository": "https://github.com/mikepharesjr/YO-VSCode/tree/master/type-script-helper",
-    "version": "1.3.11",
-    "engines": {
-        "vscode": "^1.40.0"
-    },
-    "categories": [
-        "Other"
+  "activationEvents": [
+    "onLanguage:csharp",
+    "onLanguage:markdown",
+    "onLanguage:javascript",
+    "onLanguage:json",
+    "onLanguage:typescript",
+    "onLanguage:yaml"
+  ],
+  "categories": [
+    "Other"
+  ],
+  "contributes": {
+    "commands": [
+      {
+        "category": "Calculate",
+        "command": "extension.calcAppendWithCursor",
+        "title": "Calculate and append in front of cursor"
+      },
+      {
+        "category": "Calculate",
+        "command": "extension.calcAppend",
+        "title": "Calculate and append"
+      },
+      {
+        "category": "Calculate",
+        "command": "extension.calcReplaceWithCursor",
+        "title": "Calculate and replace in front of cursor"
+      },
+      {
+        "category": "Explorer", 
+        "command": "extension.rotateExplorerSortOrder",
+        "title": "Rotate Explorer Sort Order"
+      },
+      {
+        "category": "Calculate",
+        "command": "extension.calcReplace",
+        "title": "Calculate and replace"
+      },
+      {
+        "category": "Helper",
+        "command": "copyHelper.copySyntaxInLight",
+        "title": "Copy Syntax In Light Theme"
+      },
+      {
+        "category": "Helper",
+        "command": "open-in-new-window.open",
+        "title": "Open in New Window"
+      },
+      {
+        "category": "Helper",
+        "command": "promiseLinesHelper.codeGeneratorQuickPick",
+        "title": "Code Generator - Quick Pick"
+      },
+      {
+        "category": "Helper",
+        "command": "promiseLinesHelper.genericFileFolderHelper",
+        "title": "Generic - File-Folder-Helper"
+      },
+      {
+        "category": "Helper",
+        "command": "promiseLinesHelper.insertDateTime",
+        "title": "Insert DateTime"
+      },
+      {
+        "category": "Helper",
+        "command": "promiseLinesHelper.insertAllExtensions",
+        "title": "Insert All Extensions (Not Disabled)"
+      },
+      {
+        "category": "Helper",
+        "command": "promiseLinesHelper.transformToParamCase",
+        "title": "Transform to Param Case"
+      },
+      {
+        "category": "Helper",
+        "command": "promiseLinesHelper.transformToPopperCase",
+        "title": "Transform to Popper Case"
+      },
+      {
+        "category": "Helper",
+        "command": "readOnlyLinesHelper.searchGoogle",
+        "title": "Search Google"
+      },
+      {
+        "category": "Kanban",
+        "command": "kanban.openInNewWindow",
+        "title": "Open Sub-Kanban in New Window"
+      },
+      {
+        "category": "Kanban",
+        "command": "kanban.openWithTextEditor",
+        "title": "Open with Text Editor Kanban"
+      },
+      {
+        "category": "Leominster",
+        "command": "webview.backlogLeominster",
+        "title": "Backlog (Bugs & Features with parents)"
+      },
+      {
+        "category": "Leominster",
+        "command": "webview.costOfDelayLeominster",
+        "title": "Cost of Delay (CoD)"
+      },
+      {
+        "category": "Leominster",
+        "command": "webview.costOfDelayLiveLeominster",
+        "title": "Cost of Delay (CoD) - Live Update"
+      },
+      {
+        "category": "Leominster",
+        "command": "webview.costOfDelayEffortLeominster",
+        "title": "Effort"
+      },
+      {
+        "category": "Leominster",
+        "command": "webview.costOfDelayWSJFLeominster",
+        "title": "Weightest Shortest Job First calculation (WSJF)"
+      },
+      {
+        "category": "Markdown",
+        "command": "markdown.newMarkdownFile",
+        "title": "New Markdown File"
+      },
+      {
+        "category": "Mesa",
+        "command": "webview.backlogMesa",
+        "title": "Backlog (Bugs & Features with parents)"
+      },
+      {
+        "category": "Mesa",
+        "command": "webview.costOfDelayMesa",
+        "title": "Cost of Delay (CoD)"
+      },
+      {
+        "category": "Mesa",
+        "command": "webview.costOfDelayLiveMesa",
+        "title": "Cost of Delay (CoD) - Live Update"
+      },
+      {
+        "category": "Mesa",
+        "command": "webview.costOfDelayEffortMesa",
+        "title": "Effort"
+      },
+      {
+        "category": "Mesa",
+        "command": "webview.costOfDelayWSJFMesa",
+        "title": "Weightest Shortest Job First calculation (WSJF)"
+      },
+      {
+        "category": "Quick Fix",
+        "command": "replaceLinesHelper.quickFixCamelCaseProperties",
+        "title": "Camel Case Properties"
+      },
+      {
+        "category": "Quick Fix",
+        "command": "replaceLinesHelper.quickFixCS0108",
+        "title": " CS0108 (Data Annotations)"
+      },
+      {
+        "category": "Quick Fix",
+        "command": "replaceLinesHelper.quickFixInstanceFieldToCalisthenics",
+        "title": "Instance Field to Calisthenics"
+      },
+      {
+        "category": "Quick Fix",
+        "command": "replaceLinesHelper.quickFixProperCaseProperties",
+        "title": "Proper Case Properties"
+      },
+      {
+        "category": "Quick Fix",
+        "command": "replaceLinesHelper.quickFixPublic",
+        "title": "Public (Expression Body)"
+      },
+      {
+        "category": "Replace",
+        "command": "replaceLinesHelper.addCSharpComment",
+        "title": "Add C# Comment"
+      },
+      {
+        "category": "Replace",
+        "command": "replaceLinesHelper.addVBComment",
+        "title": "Add VB Comment"
+      },
+      {
+        "category": "Replace",
+        "command": "replaceLinesHelper.convertToRegularExpression",
+        "title": "Convert to Regular Expression"
+      },
+      {
+        "category": "Replace",
+        "command": "replaceLinesHelper.cutEachLine",
+        "title": "Cut each line after |||"
+      },
+      {
+        "category": "Replace",
+        "command": "replaceLinesHelper.distinctLines",
+        "title": "Distinct Lines"
+      },
+      {
+        "category": "Replace",
+        "command": "replaceLinesHelper.expandSql",
+        "title": "Expand Sql"
+      },
+      {
+        "category": "Replace",
+        "command": "replaceLinesHelper.listToListFamily",
+        "title": "List to list family (Kristy, Mike ...)"
+      },
+      {
+        "category": "Replace",
+        "command": "replaceLinesHelper.listToListWrappedComma",
+        "title": "List to list wrapped comma"
+      },
+      {
+        "category": "Replace",
+        "command": "replaceLinesHelper.prettySql",
+        "title": "Pretty Sql"
+      },
+      {
+        "category": "Replace",
+        "command": "replaceLinesHelper.removeComment",
+        "title": "Remove comment"
+      },
+      {
+        "category": "Replace",
+        "command": "replaceLinesHelper.sortLength",
+        "title": "Sort by Length"
+      },
+      {
+        "category": "Replace",
+        "command": "replaceLinesHelper.sortNormal",
+        "title": "My Sort lines (ascending, case sensitive)"
+      },
+      {
+        "category": "Replace",
+        "command": "replaceLinesHelper.splitBySpaceReverseJoinSort",
+        "title": "Split by Space Reverse Join Sort lines (ascending, case sensitive)"
+      },
+      {
+        "category": "Replace",
+        "command": "replaceLinesHelper.unwrapSql",
+        "title": "Un-wrap Sql"
+      },
+      {
+        "category": "Replace",
+        "command": "replaceLinesHelper.wrapSqlCSharp",
+        "title": "Wrap Sql for C#"
+      },
+      {
+        "category": "Replace",
+        "command": "replaceLinesHelper.wrapSqlVB",
+        "title": "Wrap Sql for VB"
+      },
+      {
+        "category": "Webview",
+        "command": "webview.example",
+        "title": "Webview Example"
+      }
     ],
-    "main": "./out/extension.js",
-    "activationEvents": [
-		"onCommand:open-in-new-window.open",
-        "onCommand:promiseLinesHelper.codeGeneratorQuickPick",
-        "onCommand:readOnlyLinesHelper.searchGoogle",
-        "onCommand:replaceLinesHelper.addCSharpComment",
-        "onCommand:replaceLinesHelper.addVBComment",
-        "onCommand:replaceLinesHelper.convertToRegularExpression",
-        "onCommand:replaceLinesHelper.cutEachLine",
-        "onCommand:replaceLinesHelper.expandSql",
-        "onCommand:replaceLinesHelper.listToListFamily",
-        "onCommand:replaceLinesHelper.listToListWrappedComma",
-        "onCommand:replaceLinesHelper.prettySql",
-        "onCommand:replaceLinesHelper.quickFixCamelCaseProperties",
-        "onCommand:replaceLinesHelper.quickFixCS0108",
-        "onCommand:replaceLinesHelper.quickFixInstanceFieldToCalisthenics",
-        "onCommand:replaceLinesHelper.quickFixProperCaseProperties",
-        "onCommand:replaceLinesHelper.quickFixPublic",
-        "onCommand:replaceLinesHelper.removeComment",
-        "onCommand:replaceLinesHelper.sortLength",
-        "onCommand:replaceLinesHelper.sortNormal",
-        "onCommand:replaceLinesHelper.unwrapSql",
-        "onCommand:replaceLinesHelper.wrapSqlCSharp",
-        "onCommand:replaceLinesHelper.wrapSqlVB"
-    ],
-    "contributes": {
-        "commands": [
-            {
-                "command": "open-in-new-window.open",
-                "title": "Open in New Window"
-            },
-            {
-                "command": "promiseLinesHelper.codeGeneratorQuickPick",
-                "title": "Code Generator - Quick Pick"
-            },
-            {
-                "command": "readOnlyLinesHelper.searchGoogle",
-                "title": "Search Google"
-            },
-            {
-                "command": "replaceLinesHelper.addCSharpComment",
-                "title": "Add C# Comment"
-            },
-            {
-                "command": "replaceLinesHelper.addVBComment",
-                "title": "Add VB Comment"
-            },
-            {
-                "command": "replaceLinesHelper.convertToRegularExpression",
-                "title": "Convert to Regular Expression"
-            },
-            {
-                "command": "replaceLinesHelper.cutEachLine",
-                "title": "Cut each line after |||"
-            },
-            {
-                "command": "replaceLinesHelper.expandSql",
-                "title": "Expand Sql"
-            },
-            {
-                "command": "replaceLinesHelper.listToListFamily",
-                "title": "List to list family (Kristy, Mike ...)"
-            },
-            {
-                "command": "replaceLinesHelper.listToListWrappedComma",
-                "title": "List to list wrapped comma"
-            },
-            {
-                "command": "replaceLinesHelper.prettySql",
-                "title": "Pretty Sql"
-            },
-            {
-                "command": "replaceLinesHelper.quickFixCamelCaseProperties",
-                "title": "Quick Fix - Camel Case Properties"
-            },
-            {
-                "command": "replaceLinesHelper.quickFixCS0108",
-                "title": "Quick Fix -  CS0108 (Data Annotations)"
-            },
-            {
-                "command": "replaceLinesHelper.quickFixInstanceFieldToCalisthenics",
-                "title": "Quick Fix - Instance Field to Calisthenics"
-            },
-            {
-                "command": "replaceLinesHelper.quickFixProperCaseProperties",
-                "title": "Quick Fix - Proper Case Properties"
-            },
-            {
-                "command": "replaceLinesHelper.quickFixPublic",
-                "title": "Quick Fix - Public (Expression Body)"
-            },
-            {
-                "command": "replaceLinesHelper.removeComment",
-                "title": "Remove comment"
-            },
-            {
-                "command": "replaceLinesHelper.sortLength",
-                "title": "Sort by Length"
-            },
-            {
-                "command": "replaceLinesHelper.sortNormal",
-                "title": "My Sort lines (ascending, case sensitive)"
-            },
-            {
-                "command": "replaceLinesHelper.unwrapSql",
-                "title": "Un-wrap Sql"
-            },
-            {
-                "command": "replaceLinesHelper.wrapSqlCSharp",
-                "title": "Wrap Sql for C#"
-            },
-            {
-                "command": "replaceLinesHelper.wrapSqlVB",
-                "title": "Wrap Sql for VB"
-            }
-        ],
-        "menus": {
-			"explorer/context": [
-                {
-                    "command": "open-in-new-window.open",
-                    "group": "openInNewWindowGroup"
-                }
-            ]
+    "configuration": {
+      "properties": {
+        "fileTemplates.author": {
+          "default": null,
+          "description": "Value to use to replace #{author} variable.",
+          "type": [
+            "string",
+            "Mike Phares"
+          ]
+        },
+        "fileTemplates.company": {
+          "default": null,
+          "description": "Value to use to replace #{company} variable.",
+          "type": [
+            "string",
+            "Infineon Technologies Americas Corp."
+          ]
         }
-    },
-    "scripts": {
-        "vscode:prepublish": "npm run compile",
-        "compile": "tsc -p ./",
-        "watch": "tsc -watch -p ./",
-        "pretest": "npm run compile",
-        "test": "node ./out/test/runTest.js"
-    },
-    "devDependencies": {
-        "@types/glob": "^7.1.1",
-        "@types/mocha": "^5.2.7",
-        "@types/node": "^12.11.7",
-        "@types/vscode": "^1.40.0",
-        "glob": "^7.1.5",
-        "mocha": "^9.1.3",
-        "tslint": "^5.20.0",
-        "typescript": "^3.9.10",
-        "vscode-test": "^1.2.2"
+      },
+      "title": "Cost of Delay Helper Configuration",
+      "type": "object"
     }
-}
+  },
+  "dependencies": {
+    "@vscode/vsce": "^3.2.1",
+    "polka": "^0.5.2"
+  },
+  "description": "Cost of Delay Helper",
+  "devDependencies": {
+    "@nodelib/fs.stat": "^3.0.0",
+    "@types/mocha": "^10.0.6",
+    "@types/node": "^18.11.0",
+    "@types/vscode": "^1.63.0",
+    "@typescript-eslint/eslint-plugin": "^5.40.0",
+    "@typescript-eslint/parser": "^5.40.0",
+    "@vscode/test-electron": "^2.4.0",
+    "@vscode/test-web": "*",
+    "concurrently": "^8.2.2",
+    "editor-calc": "^2.1.0",
+    "eslint": "^8.25.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-prettier": "^4.2.1",
+    "glob": "^10.4.1",
+    "mocha": "^10.4.0",
+    "prettier": "^2.7.1",
+    "ts-loader": "^9.4.1",
+    "typescript": "^4.8.4",
+    "webpack": "^5.74.0",
+    "webpack-cli": "^4.10.0"
+  },
+  "displayName": "Cost of Delay Helper",
+  "engines": {
+    "vscode": "^1.79.0"
+  },
+  "keywords": [
+    "Backlog",
+    "CoD",
+    "Cost of Delay (CoD)",
+    "FI",
+    "Infineon",
+    "Leominster",
+    "Mesa",
+    "Phares",
+    "Weightest Shortest Job First calculation (WSJF)",
+    "WSJF"
+  ],
+  "main": "./dist/extension.js",
+  "name": "infineon-technologies-ag-mesa-fi-cost-of-delay-helper",
+  "publisher": "Infineon-Technologies-AG-Mesa-FI",
+  "repository": "https://gitea.phares.duckdns.org/phares3757/yo-vscode.git",
+  "scripts": {
+    "tsc-build": "tsc",
+    "tsc-clean": "tsc --build --clean",
+    "vscode:package": "node node_modules/@vscode/vsce/vsce package",
+    "vscode:login": "node node_modules/@vscode/vsce/vsce login Infineon-Technologies-AG-Mesa-FI",
+    "vscode:ls-publishers": "node node_modules/@vscode/vsce/vsce ls-publishers",
+    "vscode:publish": "node node_modules/@vscode/vsce/vsce publish",
+    "watch": "concurrently \"rollup -c -w\" \"webpack --watch --config ./build/node-extension.webpack.config.js\"",
+    "webpack": "webpack --config ./build/node-extension.webpack.config.js"
+  },
+  "version": "1.119.0"
+}

type-script-helper/rollup.config.js

@@ -0,0 +1,68 @@
+import svelte from "rollup-plugin-svelte";
+import resolve from "@rollup/plugin-node-resolve";
+import commonjs from "@rollup/plugin-commonjs";
+import { terser } from "rollup-plugin-terser";
+import sveltePreprocess from "svelte-preprocess";
+import typescript from "@rollup/plugin-typescript";
+import path from "path";
+import fs from "fs";
+
+const production = !process.env.ROLLUP_WATCH;
+
+export default fs
+  .readdirSync(path.join(__dirname, "webviews", "pages"))
+  .map((input) => {
+    const name = input.split(".")[0];
+    return {
+      input: "webviews/pages/" + input,
+      output: {
+        sourcemap: true,
+        format: "iife",
+        name: "app",
+        file: "out/compiled/" + name + ".js",
+      },
+      plugins: [
+        svelte({
+          // enable run-time checks when not in production
+          dev: !production,
+          // we'll extract any component CSS out into
+          // a separate file - better for performance
+          css: (css) => {
+            css.write(name + ".css");
+          },
+          preprocess: sveltePreprocess(),
+        }),
+
+        // If you have external dependencies installed from
+        // npm, you'll most likely need these plugins. In
+        // some cases you'll need additional configuration -
+        // consult the documentation for details:
+        // https://github.com/rollup/plugins/tree/master/packages/commonjs
+        resolve({
+          browser: true,
+          dedupe: ["svelte"],
+        }),
+        commonjs(),
+        typescript({
+          tsconfig: "webviews/tsconfig.json",
+          sourceMap: !production,
+          inlineSources: !production,
+        }),
+
+        // In dev mode, call `npm run start` once
+        // the bundle has been generated
+        // !production && serve(),
+
+        // Watch the `public` directory and refresh the
+        // browser on changes when not in production
+        // !production && livereload("public"),
+
+        // If we're building for production (npm run build
+        // instead of npm run dev), minify
+        production && terser(),
+      ],
+      watch: {
+        clearScreen: false,
+      },
+    };
+  });

type-script-helper/src/Card.ts

@@ -0,0 +1,22 @@
+import { H2HexColor } from "./H2HexColor";
+import { LineNumber } from "./LineNumber";
+import { H2NoCheckboxes } from "./H2NoCheckboxes";
+import { H2WithCheckboxes } from "./H2WithCheckboxes";
+
+export type Card = {
+  Assignees: Array<string>;
+  CreationDateTime: Date;
+  Directory: string;
+  Extension: string;
+  File: string;
+  FileName: string;
+  FileNameWithoutExtension: string;
+  H1: string;
+  H2HexColorCollection: Array<H2HexColor>;
+  H2NoCheckboxesCollection: Array<H2NoCheckboxes>;
+  H2WithCheckboxesCollection: Array<H2WithCheckboxes>;
+  LastWriteDateTime: Date;
+  LineNumber: LineNumber;
+  RequestedDateTime: string;
+  Type: string;
+};

type-script-helper/src/ColumnsToCardsWebviewViewProvider.ts

@@ -0,0 +1,188 @@
+import { Card } from "./Card";
+import { readFile } from "fs";
+import * as vscode from "vscode";
+import { getNonce } from "./getNonce";
+import { PostMessage } from "./PostMessage";
+import { apiBaseUrl, key } from "./constants";
+import { ExecException, exec } from 'child_process';
+
+export function refreshSidebarLogic(): any {
+  vscode.commands.executeCommand("workbench.action.closeSidebar").then(_ => {
+    vscode.commands.executeCommand("workbench.view.extension.columns-to-cards-sidebar-view");
+  });
+}
+
+function columnsToCardsRead(webviewView: vscode.WebviewView, columnsToCardsUri: vscode.Uri, err: NodeJS.ErrnoException | null, data: string | Buffer) {
+  if (err)
+    vscode.window.showInformationMessage(`<${columnsToCardsUri.fsPath}> doesn't exist! ${err.message}`);
+  const columnsToCards: Record<string, Array<Card>> = {};
+  const jsonObject: any = JSON.parse(data.toString('utf8'));
+  for (const property in jsonObject) {
+    columnsToCards[property] = jsonObject[property];
+  }
+  const postMessage: PostMessage = { type: "columns-to-cards", value: columnsToCards };
+  webviewView.webview.postMessage(postMessage);
+}
+
+function execCallback(webviewView: vscode.WebviewView, destination: vscode.Uri, error: ExecException | null, stdout: string, stderr: string) {
+  if (error) {
+    vscode.window.showInformationMessage(error.message);
+    return;
+  }
+  if (stderr) {
+    vscode.window.showInformationMessage(stderr);
+    return;
+  }
+  console.log(`stdout: ${stdout}`);
+  const columnsToCards = vscode.Uri.joinPath(destination, "columnsToCards.json");
+  readFile(columnsToCards.fsPath, (err, data) =>
+    columnsToCardsRead(webviewView, columnsToCards, err, data));
+};
+
+async function postColumnsToCards(extensionUri: vscode.Uri, webviewView: vscode.WebviewView) {
+  if (vscode.workspace.workspaceFolders === undefined)
+    vscode.window.showInformationMessage("Open workspace first!");
+  else {
+    const workspaceFoldersZero = vscode.workspace.workspaceFolders[0].uri;
+    const destination: vscode.Uri = vscode.Uri.joinPath(workspaceFoldersZero, ".vscode", "helper");
+    const fileFolderHelper: vscode.Uri = vscode.Uri.joinPath(extensionUri, "net8.0", "win-x64", "publish", "File-Folder-Helper.exe");
+    const command: string = `${fileFolderHelper.fsPath} s M "${workspaceFoldersZero.fsPath}" -d "${destination.fsPath}"`;
+    exec(command, (error, stdout, stderr) =>
+      execCallback(webviewView, destination, error, stdout, stderr));
+  }
+}
+
+function getToken(workspaceState: vscode.Memento, webviewView: vscode.WebviewView) {
+  webviewView.webview.postMessage({
+    type: "token",
+    value: workspaceState.get(key),
+  });
+}
+
+function authenticate(workspaceState: vscode.Memento, webviewView: vscode.WebviewView) {
+  webviewView.webview.postMessage({
+    type: "token",
+    value: workspaceState.get(key),
+  });
+}
+
+function logout(workspaceState: vscode.Memento) {
+  workspaceState.update(key, "");
+}
+
+async function openCard(value: any) {
+  if (vscode.workspace.workspaceFolders === undefined)
+    vscode.window.showInformationMessage("Open workspace first!");
+  else {
+    if (!value.File)
+      vscode.window.showInformationMessage("File wasn't passed!");
+    else {
+      const textDocument: vscode.TextDocument = await vscode.workspace.openTextDocument(value.File);
+      vscode.window.showTextDocument(textDocument);
+    }
+  }
+}
+
+export class ColumnsToCardsWebviewViewProvider implements vscode.WebviewViewProvider {
+  _view?: vscode.WebviewView;
+
+  constructor(private readonly _extensionContext: vscode.ExtensionContext) {
+  }
+
+  public revive(panel: vscode.WebviewView) {
+    this._view = panel;
+  }
+
+  public resolveWebviewView(webviewView: vscode.WebviewView) {
+    this._view = webviewView;
+
+    webviewView.webview.options = {
+      // Allow scripts in the webview
+      enableScripts: true,
+
+      localResourceRoots: [this._extensionContext.extensionUri],
+    };
+
+    webviewView.webview.html = this._getHtmlForWebview(webviewView.webview);
+
+    webviewView.webview.onDidReceiveMessage(async (postMessage: PostMessage) => {
+      switch (postMessage.type) {
+        case "logout":
+          logout(this._extensionContext.workspaceState);
+          break;
+        case "authenticate":
+          authenticate(this._extensionContext.workspaceState, webviewView);
+          break;
+        case "get-token":
+          getToken(this._extensionContext.workspaceState, webviewView);
+          break;
+        case "get-columns-to-cards":
+          postColumnsToCards(this._extensionContext.extensionUri, webviewView);
+          break;
+        case "open-card":
+          openCard(postMessage.value);
+          break;
+        case "on-info":
+          if (!postMessage.value)
+            return;
+          vscode.window.showInformationMessage(postMessage.value);
+          break;
+        case "on-error":
+          if (!postMessage.value)
+            return;
+          vscode.window.showErrorMessage(postMessage.value);
+          break;
+        default:
+          vscode.window.showErrorMessage(postMessage.type);
+          break;
+      }
+    });
+  }
+
+  private _getHtmlForWebview(webview: vscode.Webview) {
+    const styleResetUri = webview.asWebviewUri(
+      vscode.Uri.joinPath(this._extensionContext.extensionUri, "media", "reset.css")
+    );
+    const styleVSCodeUri = webview.asWebviewUri(
+      vscode.Uri.joinPath(this._extensionContext.extensionUri, "media", "vscode.css")
+    );
+
+    const scriptUri = webview.asWebviewUri(
+      vscode.Uri.joinPath(this._extensionContext.extensionUri, "out", "compiled/ColumnsToCards.js")
+    );
+    const styleMainUri = webview.asWebviewUri(
+      vscode.Uri.joinPath(this._extensionContext.extensionUri, "out", "compiled/ColumnsToCards.css")
+    );
+
+    // Use a nonce to only allow a specific script to be run.
+    const nonce = getNonce();
+
+    return `<!DOCTYPE html>
+			<html lang="en">
+			<head>
+				<meta charset="UTF-8">
+				<!--
+					Use a content security policy to only allow loading images from https or from our extension directory,
+					and only allow scripts that have a specific nonce.
+        -->
+        <meta http-equiv="Content-Security-Policy"
+          content="img-src https: data:;
+          style-src 'unsafe-inline' ${webview.cspSource};
+          script-src 'nonce-${nonce}';">
+				<meta name="viewport" content="width=device-width, initial-scale=1.0">
+				<link href="${styleResetUri}" rel="stylesheet">
+				<link href="${styleVSCodeUri}" rel="stylesheet">
+        <link href="${styleMainUri}" rel="stylesheet">
+        <script nonce="${nonce}">
+          const acquiredVsCodeApi = acquireVsCodeApi();
+          const apiBaseUrl = ${JSON.stringify(apiBaseUrl)}
+        </script>
+			</head>
+      <body>
+				<script nonce="${nonce}" src="${scriptUri}"></script>
+			</body>
+			</html>`;
+  }
+}
+
+export const refreshSidebar = () => refreshSidebarLogic();

type-script-helper/src/H2HexColor.ts

@@ -0,0 +1,4 @@
+export type H2HexColor = {
+  H2: string;
+  HexColor: string;
+};

type-script-helper/src/H2NoCheckboxes.ts

@@ -0,0 +1,5 @@
+
+export type H2NoCheckboxes = {
+  H2: string;
+  Lines: Array<string>;
+};

type-script-helper/src/H2WithCheckboxes.ts

@@ -0,0 +1,7 @@
+
+export type H2WithCheckboxes = {
+  Completed: number;
+  H2: string;
+  NotCompleted: number;
+  Total: number;
+};

type-script-helper/src/LineNumber.ts

@@ -0,0 +1,9 @@
+
+export type LineNumber = {
+  Created: number;
+  H1: number;
+  FrontMatterYamlEnd: number;
+  Status: number;
+  Type: number;
+  Updated: number;
+};

type-script-helper/src/PostMessage.ts

@@ -0,0 +1,5 @@
+
+export type PostMessage = {
+  type: string;
+  value: any;
+};

type-script-helper/src/WebviewPanelCostOfDelay.ts

@@ -0,0 +1,236 @@
+import * as vscode from "vscode";
+import { getNonce } from "./getNonce";
+import { apiBaseUrl } from "./constants";
+import { PostMessage } from "./PostMessage";
+import { title } from "process";
+
+export class WebviewPanelCostOfDelay {
+  /**
+   * Track the currently panel. Only allow a single panel to exist at a time.
+   */
+  public static _site: string;
+  public static _view: string;
+  public static _title: string;
+  public static currentPanel: WebviewPanelCostOfDelay | undefined;
+
+  public static readonly viewType = "web-view-panel";
+
+  private _disposables: vscode.Disposable[] = [];
+
+  public static createOrShow(extensionContext: vscode.ExtensionContext, site: string, view: string) {
+    this._site = site;
+    this._view = view;
+
+    const column = vscode.window.activeTextEditor
+      ? vscode.window.activeTextEditor.viewColumn
+      : undefined;
+
+    const title = view === '' ? 'Cost of Delay (CoD)' :
+      view === 'EFFORT' ? 'Effort' :
+        view === 'LIVE' ? 'Cost of Delay (CoD) - Live Update' :
+          view === 'HTML' ? 'Backlog (Bugs & Features with parents)' :
+            view === 'WSJF' ? 'Weightest Shortest Job First calculation (WSJF)' :
+              'CoD';
+    this._title = title;
+
+    // If we already have a panel, show it.
+    if (WebviewPanelCostOfDelay.currentPanel) {
+      WebviewPanelCostOfDelay.currentPanel._panel.reveal(column);
+      WebviewPanelCostOfDelay.currentPanel._update(site, title, view);
+      return;
+    }
+
+    // Otherwise, create a new panel.
+    const panel = vscode.window.createWebviewPanel(
+      WebviewPanelCostOfDelay.viewType,
+      title,
+      column || vscode.ViewColumn.One,
+      {
+        // Enable javascript in the webview
+        enableScripts: true,
+
+        // And restrict the webview to only loading content from our extension's `media` directory.
+        localResourceRoots: [
+          vscode.Uri.joinPath(extensionContext.extensionUri, "media"),
+          vscode.Uri.joinPath(extensionContext.extensionUri, "out/compiled"),
+        ],
+      }
+    );
+
+    WebviewPanelCostOfDelay.currentPanel = new WebviewPanelCostOfDelay(extensionContext, panel, site, title, view);
+  }
+
+  public static kill() {
+    WebviewPanelCostOfDelay.currentPanel?.dispose();
+    WebviewPanelCostOfDelay.currentPanel = undefined;
+  }
+
+  public static revive(panel: vscode.WebviewPanel, extensionContext: vscode.ExtensionContext) {
+    WebviewPanelCostOfDelay.currentPanel = new WebviewPanelCostOfDelay(extensionContext, panel, this._site, this._title, this._view);
+  }
+
+  private constructor(private readonly _extensionContext: vscode.ExtensionContext, private readonly _panel: vscode.WebviewPanel, site: string, title: string, view: string) {
+
+    // Set the webview's initial html content
+    this._update(site, title, view);
+
+    // Listen for when the panel is disposed
+    // This happens when the user closes the panel or when the panel is closed programmatically
+    this._panel.onDidDispose(() => this.dispose(), null, this._disposables);
+
+    // // Handle messages from the webview
+    // this._panel.webview.onDidReceiveMessage(
+    //   (message) => {
+    //     switch (message.command) {
+    //       case "alert":
+    //         vscode.window.showErrorMessage(message.text);
+    //         return;
+    //     }
+    //   },
+    //   null,
+    //   this._disposables
+    // );
+  }
+
+  public dispose() {
+    WebviewPanelCostOfDelay.currentPanel = undefined;
+
+    // Clean up our resources
+    this._panel.dispose();
+
+    while (this._disposables.length) {
+      const x = this._disposables.pop();
+      if (x) {
+        x.dispose();
+      }
+    }
+  }
+
+  private async _update(site: string, title: string, view: string) {
+    const webview = this._panel.webview;
+
+    this._panel.webview.html = this._getHtmlForWebview(site, title, view, webview);
+    webview.onDidReceiveMessage(async (postMessage: PostMessage) => {
+      switch (postMessage.type) {
+        case "on-info":
+          if (!postMessage.value)
+            return;
+          vscode.window.showInformationMessage(postMessage.value);
+          break;
+        case "on-error":
+          if (!postMessage.value)
+            return;
+          vscode.window.showErrorMessage(postMessage.value);
+          break;
+        default:
+          vscode.window.showErrorMessage(postMessage.type);
+          break;
+      }
+    });
+  }
+
+  private _getHtmlForWebview(site: string, title: string, view: string, webview: vscode.Webview) {
+    const baseUri = 'https://eaf-dev.mes.infineon.com';
+
+    if (view === 'HTML') {
+      return `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Infineon - ${title}</title>
+</head>
+<body>
+  <iframe width="100%" style="height: 100vh;" src="${baseUri}/html/mes.html?site=${site}" title="${title}">
+  </iframe>
+</body>
+</html>`;
+    }
+    else {
+      const styleBootstrapUri = webview.asWebviewUri(
+        vscode.Uri.joinPath(this._extensionContext.extensionUri, "media", "bootstrap.min.css")
+      );
+      const styleCostOfDelayUri = webview.asWebviewUri(
+        vscode.Uri.joinPath(this._extensionContext.extensionUri, "media", "cod.css")
+      );
+      const scriptJQueryUri = webview.asWebviewUri(
+        vscode.Uri.joinPath(this._extensionContext.extensionUri, "media", "jquery-1.6.4.min.js")
+      );
+      const scriptSignalRUri = webview.asWebviewUri(
+        vscode.Uri.joinPath(this._extensionContext.extensionUri, "media", "jquery.signalR-2.4.3.min.js")
+      );
+      const scriptCostOfDelayUri = webview.asWebviewUri(
+        vscode.Uri.joinPath(this._extensionContext.extensionUri, "media", "cost-of-delay.js")
+      );
+
+      // Use a nonce to only allow a specific script to be run.
+      const nonce = getNonce();
+
+      return `<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Infineon - ${title}</title>
+    <link href="${styleBootstrapUri}" rel="stylesheet" />
+    <link href="${styleCostOfDelayUri}" rel="stylesheet" />
+    <script nonce="${nonce}" src="${scriptJQueryUri}"></script>
+    <script nonce="${nonce}" src="${scriptSignalRUri}"></script>
+    <script nonce="${nonce}" src="${baseUri}/signalr/hubs"></script>
+    <script nonce="${nonce}" src="${baseUri}/js/cod-b.js?v=2025-01-22-10-49" type="text/javascript"></script>
+    <script nonce="${nonce}">
+      const _webviewSite = '${site}';
+      const _webviewView = '${view}';
+      const acquiredVsCodeApi = acquireVsCodeApi();
+      const apiBaseUrl = ${JSON.stringify(apiBaseUrl)}
+      const _webviewUsername = '${process.env.USERNAME}';
+      const _webviewMachineId = '${vscode.env.machineId}';
+    </script>
+</head>
+
+<body>
+    <div class="navbar navbar-fixed-top">
+        <div class="container-fluid">
+            <div class="navbar-header">
+                <button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-collapse">
+                    <span class="icon-bar"></span>
+                    <span class="icon-bar"></span>
+                    <span class="icon-bar"></span>
+                </button>
+                <div class="navbar-brand">
+                    <span id="siteHeader">&nbsp;</span> -
+                    <span id="th-span">&nbsp;</span>
+                    <button id="toggle">Toggle</button>
+                </div>
+            </div>
+            <div class="navbar-collapse collapse">
+                <ul class="nav navbar-nav">
+                </ul>
+                <p class="navbar-text navbar-right">
+                    &nbsp;
+                </p>
+            </div>
+        </div>
+    </div>
+    <div class="container-fluid body-content" style="margin-top: 40px; margin-left: 15px;">
+        <div id="HeaderGridDiv">
+            <table id="HeaderGrid" border="1"></table>
+        </div>
+
+        <br />&nbsp;
+
+        <div id="AllGridDiv">
+            <table id="AllGrid"></table>
+        </div>
+
+        <textarea id="AllTextarea" rows="20" cols="147"></textarea>
+    </div>
+
+  <script nonce="${nonce}" src="${scriptCostOfDelayUri}"></script>
+</body>
+
+</html>`;
+    }
+  }
+}

type-script-helper/src/WebviewPanelExample.ts

@@ -0,0 +1,166 @@
+import * as vscode from "vscode";
+import { getNonce } from "./getNonce";
+import { apiBaseUrl } from "./constants";
+import { PostMessage } from "./PostMessage";
+
+export function refreshWebviewPanelExample(extensionContext: vscode.ExtensionContext): any {
+  WebviewPanelExample.kill();
+  WebviewPanelExample.createOrShow(extensionContext);
+}
+
+export class WebviewPanelExample {
+  /**
+   * Track the currently panel. Only allow a single panel to exist at a time.
+   */
+  public static currentPanel: WebviewPanelExample | undefined;
+
+  public static readonly viewType = "web-view-panel";
+
+  private _disposables: vscode.Disposable[] = [];
+
+  public static createOrShow(extensionContext: vscode.ExtensionContext) {
+    const column = vscode.window.activeTextEditor
+      ? vscode.window.activeTextEditor.viewColumn
+      : undefined;
+
+    // If we already have a panel, show it.
+    if (WebviewPanelExample.currentPanel) {
+      WebviewPanelExample.currentPanel._panel.reveal(column);
+      WebviewPanelExample.currentPanel._update();
+      return;
+    }
+
+    // Otherwise, create a new panel.
+    const panel = vscode.window.createWebviewPanel(
+      WebviewPanelExample.viewType,
+      "Web-View-Panel",
+      column || vscode.ViewColumn.One,
+      {
+        // Enable javascript in the webview
+        enableScripts: true,
+
+        // And restrict the webview to only loading content from our extension's `media` directory.
+        localResourceRoots: [
+          vscode.Uri.joinPath(extensionContext.extensionUri, "media"),
+          vscode.Uri.joinPath(extensionContext.extensionUri, "out/compiled"),
+        ],
+      }
+    );
+
+    WebviewPanelExample.currentPanel = new WebviewPanelExample(panel, extensionContext);
+  }
+
+  public static kill() {
+    WebviewPanelExample.currentPanel?.dispose();
+    WebviewPanelExample.currentPanel = undefined;
+  }
+
+  public static revive(panel: vscode.WebviewPanel, extensionContext: vscode.ExtensionContext) {
+    WebviewPanelExample.currentPanel = new WebviewPanelExample(panel, extensionContext);
+  }
+
+  private constructor(private readonly _panel: vscode.WebviewPanel, private readonly _extensionContext: vscode.ExtensionContext) {
+
+    // Set the webview's initial html content
+    this._update();
+
+    // Listen for when the panel is disposed
+    // This happens when the user closes the panel or when the panel is closed programmatically
+    this._panel.onDidDispose(() => this.dispose(), null, this._disposables);
+
+    // // Handle messages from the webview
+    // this._panel.webview.onDidReceiveMessage(
+    //   (message) => {
+    //     switch (message.command) {
+    //       case "alert":
+    //         vscode.window.showErrorMessage(message.text);
+    //         return;
+    //     }
+    //   },
+    //   null,
+    //   this._disposables
+    // );
+  }
+
+  public dispose() {
+    WebviewPanelExample.currentPanel = undefined;
+
+    // Clean up our resources
+    this._panel.dispose();
+
+    while (this._disposables.length) {
+      const x = this._disposables.pop();
+      if (x) {
+        x.dispose();
+      }
+    }
+  }
+
+  private async _update() {
+    const webview = this._panel.webview;
+
+    this._panel.webview.html = this._getHtmlForWebview(webview);
+    webview.onDidReceiveMessage(async (postMessage: PostMessage) => {
+      switch (postMessage.type) {        
+        case "on-info":
+          if (!postMessage.value)
+            return;
+          vscode.window.showInformationMessage(postMessage.value);
+          break;
+        case "on-error":
+          if (!postMessage.value)
+            return;
+          vscode.window.showErrorMessage(postMessage.value);
+          break;
+        default:
+          vscode.window.showErrorMessage(postMessage.type);
+          break;
+      }
+    });
+  }
+
+  private _getHtmlForWebview(webview: vscode.Webview) {
+    const styleResetUri = webview.asWebviewUri(
+      vscode.Uri.joinPath(this._extensionContext.extensionUri, "media", "reset.css")
+    );
+    const styleVSCodeUri = webview.asWebviewUri(
+      vscode.Uri.joinPath(this._extensionContext.extensionUri, "media", "vscode.css")
+    );
+
+    const scriptUri = webview.asWebviewUri(
+      vscode.Uri.joinPath(this._extensionContext.extensionUri, "out", "compiled/DisplayDate.js")
+    );
+    const styleMainUri = webview.asWebviewUri(
+      vscode.Uri.joinPath(this._extensionContext.extensionUri, "out", "compiled/DisplayDate.css")
+    );
+
+    // Use a nonce to only allow a specific script to be run.
+    const nonce = getNonce();
+
+    return `<!DOCTYPE html>
+			<html lang="en">
+			<head>
+				<meta charset="UTF-8">
+				<!--
+					Use a content security policy to only allow loading images from https or from our extension directory,
+					and only allow scripts that have a specific nonce.
+        -->
+        <meta http-equiv="Content-Security-Policy"
+          content="img-src https: data:;
+          style-src 'unsafe-inline' ${webview.cspSource};
+          script-src 'nonce-${nonce}';">
+				<meta name="viewport" content="width=device-width, initial-scale=1.0">
+				<link href="${styleResetUri}" rel="stylesheet">
+				<link href="${styleVSCodeUri}" rel="stylesheet">
+        <link href="${styleMainUri}" rel="stylesheet">
+        <script nonce="${nonce}">
+          const acquiredVsCodeApi = acquireVsCodeApi();
+          const apiBaseUrl = ${JSON.stringify(apiBaseUrl)}
+        </script>
+			</head>
+      <body>
+				<script nonce="${nonce}" src="${scriptUri}"></script>
+			</body>
+			</html>`;
+  }
+}

type-script-helper/src/calculator.ts

@@ -0,0 +1,193 @@
+import * as vscode from 'vscode';
+import * as editorCalc from 'editor-calc';
+
+export class CalcProvider implements vscode.CompletionItemProvider {
+  public enableActive: boolean;
+
+  private decorationType: vscode.TextEditorDecorationType;
+
+  constructor(
+    public config: vscode.WorkspaceConfiguration,
+    private onError: (error: unknown) => any,
+  ) {
+    this.enableActive = false;
+    this.decorationType = vscode.window.createTextEditorDecorationType({
+      dark: {
+        border: '1px dashed gray',
+      },
+      light: {
+        border: '1px dashed black',
+      },
+    });
+  }
+
+  public async highlight(range: vscode.Range) {
+    const editor = vscode.window.activeTextEditor;
+    if (editor) {
+      editor.setDecorations(this.decorationType, [range]);
+    }
+  }
+
+  public async clearHighlight() {
+    const editor = vscode.window.activeTextEditor;
+    if (editor) {
+      editor.setDecorations(this.decorationType, []);
+    }
+  }
+
+  public calculateLine(
+    position: vscode.Position,
+    exprLine: string,
+  ): {
+    skip: number;
+    result: string;
+    insertText: string;
+    expressionRange: vscode.Range;
+    expressionWithEqualSignRange: vscode.Range;
+    expressionEndRange: vscode.Range;
+  } | null {
+    let skip, result;
+    try {
+      ({ skip, result } = editorCalc.calculate(exprLine));
+    } catch (error) {
+      this.onError(error);
+      return null;
+    }
+    const formulaRaw = exprLine.slice(skip);
+    const leftMatches = formulaRaw.match(/^\s+/);
+    const leftEmpty = leftMatches ? leftMatches[0].length : 0;
+    const rightMatches = formulaRaw.match(/[\s=]+$/);
+    const rightEmpty = rightMatches ? rightMatches[0].length : 0;
+
+    const insertText = exprLine.endsWith(' =') ? ` ${result}` : result;
+
+    return {
+      skip,
+      result,
+      insertText,
+      expressionRange: new vscode.Range(
+        position.line,
+        skip + leftEmpty,
+        position.line,
+        position.character - rightEmpty,
+      ),
+      expressionWithEqualSignRange: new vscode.Range(
+        position.line,
+        skip + leftEmpty,
+        position.line,
+        position.character,
+      ),
+      expressionEndRange: new vscode.Range(
+        position.line,
+        position.character,
+        position.line,
+        position.character,
+      ),
+    };
+  }
+
+  private getCompletionResultsFromExtraCursors(document: vscode.TextDocument): {
+    additionalReplacements: vscode.Range[];
+    additionalTextInserts: string[];
+    additionalResults: string[];
+  } {
+    const additionalReplacements = [];
+    const additionalTextInserts = [];
+    const additionalResults = [];
+
+    const editor = vscode.window.activeTextEditor;
+    if (editor) {
+      for (const selection of editor.selections.slice(1)) {
+        const position = selection.active;
+        const exprLine = document.getText(
+          new vscode.Range(new vscode.Position(position.line, 0), position),
+        );
+        const lineCalcResult = this.calculateLine(position, exprLine);
+        if (lineCalcResult == null) {
+          continue;
+        }
+        const { expressionWithEqualSignRange, insertText, result } =
+          lineCalcResult;
+        additionalReplacements.push(expressionWithEqualSignRange);
+        additionalTextInserts.push(insertText);
+        additionalResults.push(result);
+      }
+    }
+
+    return { additionalReplacements, additionalTextInserts, additionalResults };
+  }
+
+  public async provideCompletionItems(
+    document: vscode.TextDocument,
+    position: vscode.Position,
+    _token: vscode.CancellationToken,
+    _context: vscode.CompletionContext,
+  ): Promise<vscode.CompletionItem[]> {
+    const exprLine = document.getText(
+      new vscode.Range(new vscode.Position(position.line, 0), position),
+    );
+    if (!this.enableActive && !exprLine.trimRight().endsWith('=')) {
+      return [];
+    }
+    const lineCalcResult = this.calculateLine(position, exprLine);
+    if (lineCalcResult == null) {
+      return [];
+    }
+    const {
+      skip,
+      result,
+      expressionRange,
+      expressionWithEqualSignRange,
+      expressionEndRange,
+      insertText,
+    } = lineCalcResult;
+
+    this.clearHighlight().catch(this.onError);
+
+    this.highlight(expressionRange).catch(this.onError);
+
+    const { additionalReplacements, additionalTextInserts, additionalResults } =
+      this.getCompletionResultsFromExtraCursors(document);
+    const documentationPostfix =
+      additionalResults.length > 0 ? ' (multiple)' : '';
+
+    return [
+      {
+        label: result,
+        kind: vscode.CompletionItemKind.Constant,
+        detail: `calc append${documentationPostfix}`,
+        documentation: `\`${exprLine
+          .slice(skip)
+          .trimStart()}${insertText}\`${documentationPostfix}`,
+        range: expressionEndRange,
+        additionalTextEdits: [
+          vscode.TextEdit.insert(expressionWithEqualSignRange.end, insertText),
+          ...additionalReplacements.map((replacementRange, i) =>
+            vscode.TextEdit.insert(replacementRange.end, additionalTextInserts[i]),
+          ),
+        ],
+        insertText: '', // text specified here will be inserted on every line
+      },
+      {
+        label: result,
+        kind: vscode.CompletionItemKind.Constant,
+        detail: `calc replace${documentationPostfix}`,
+        documentation: `\`${result}\`${documentationPostfix}`,
+        additionalTextEdits: [
+          vscode.TextEdit.replace(expressionWithEqualSignRange, result),
+          ...additionalReplacements.map((replacementRange, i) =>
+            vscode.TextEdit.replace(replacementRange, additionalResults[i]),
+          ),
+        ],
+        insertText: '',
+      },
+    ];
+  }
+
+  async resolveCompletionItem(
+    item: vscode.CompletionItem,
+    _token: vscode.CancellationToken,
+  ): Promise<vscode.CompletionItem> {
+    return item;
+  }
+}

type-script-helper/src/constants.ts

@@ -0,0 +1,2 @@
+export const apiBaseUrl: string = "http://localhost:3002";
+export const key: string = "type-script-helper";

type-script-helper/src/copyHelper.ts

@@ -0,0 +1,37 @@
+import * as vscode from 'vscode';
+
+async function copySyntaxInLightLogic(): Promise<any> {
+    try {
+        // Get the current configuration
+        const config = vscode.workspace.getConfiguration();
+
+        // Get the current color theme
+        const currentTheme = config.get("workbench.colorTheme");
+
+        // Set the color theme to "Default Light+"
+        await config.update(
+            "workbench.colorTheme",
+            "Default Light Modern",
+            vscode.ConfigurationTarget.Global
+        );
+
+        // Copy Selected Text
+        await vscode.commands.executeCommand(
+            "editor.action.clipboardCopyAction"
+        );
+
+        // Show success message
+        vscode.window.showInformationMessage("Text copied in Light Mode");
+
+        // Switch back to dark theme
+        await config.update(
+            "workbench.colorTheme",
+            currentTheme,
+            vscode.ConfigurationTarget.Global
+        );
+    } catch (error) {
+        vscode.window.showErrorMessage(`Error: ${error}`);
+    }
+}
+
+export const copySyntaxInLight = () => copySyntaxInLightLogic();

type-script-helper/src/extension.ts

@@ -1,48 +1,152 @@
 // The module 'vscode' contains the VS Code extensibility API
 // Import the module and reference it with the alias vscode in your code below
 import * as vscode from 'vscode';
+import * as Calculator from './calculator';
+import * as copyHelper from './copyHelper';
+import * as kanbanHelper from './kanbanHelper';
+import * as markdownHelper from './markdownHelper';
+import * as settingsHelper from './settingsHelper';
+import * as promiseLinesHelper from './promiseLinesHelper';
 import * as replaceLinesHelper from './replaceLinesHelper';
 import * as readOnlyLinesHelper from './readOnlyLinesHelper';
-import * as promiseLinesHelper from './promiseLinesHelper';
+import * as WebviewPanelExample from './WebviewPanelExample';
+import * as WebviewPanelCostOfDelay from './WebviewPanelCostOfDelay';
+import * as ColumnsToCardsWebviewViewProvider from './ColumnsToCardsWebviewViewProvider';
 
-// this method is called when your extension is activated
-// your extension is activated the very first time the command is executed
-export function activate(context: vscode.ExtensionContext) {
+// This method is called when your extension is activated
+// Your extension is activated the very first time the command is executed
+export async function activate(extensionContext: vscode.ExtensionContext) {
 
-    const openCommand = 'open-in-new-window.open';
+	const columnsToCardsWebviewViewProvider = new ColumnsToCardsWebviewViewProvider.ColumnsToCardsWebviewViewProvider(extensionContext);
 
-	// Use the console to output diagnostic information (console.log) and errors (console.error)
-	// This line of code will only be executed once when your extension is activated
-	console.log('Congratulations, your extension "type-script-helper" is now active!');
+	const item = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right);
+	item.text = "$(beaker) Show Kanban";
+	// item.command = "kanban.show";
+	item.show();
+	extensionContext.subscriptions.push(vscode.window.registerWebviewViewProvider("columns-to-cards-webview-view-provider", columnsToCardsWebviewViewProvider));
 
-	// The command has been defined in the package.json file
-	// Now provide the implementation of the command with registerCommand
-	// The commandId parameter must match the command field in package.json
-	// let disposable = vscode.commands.registerCommand('extension.helloWorld', () => {
-	// 	// The code you place here will be executed every time your command is executed
+	const config = vscode.workspace.getConfiguration('calc');
+	const outputChannel = vscode.window.createOutputChannel('calc');
 
-	// 	// Display a message box to the user
-	// 	vscode.window.showInformationMessage('Hello World!');
-	// });
+	const onError = (error: unknown) => {
+		if (error instanceof Error) {
+			outputChannel.appendLine(error.message);
+			if (error.stack) outputChannel.appendLine(error.stack);
+		} else {
+			outputChannel.appendLine((error as any).toString().message);
+		}
+	};
 
+	const calcProvider = new Calculator.CalcProvider(config, onError);
 
-	// context.subscriptions.push(disposable);
+	extensionContext.subscriptions.push(
+		vscode.languages.registerCompletionItemProvider('*', calcProvider, '=', ' '),
+		vscode.workspace.onDidOpenTextDocument(() => {
+			calcProvider.clearHighlight().catch(onError);
+		}),
+		vscode.window.onDidChangeTextEditorSelection(() => {
+			calcProvider.clearHighlight().catch(onError);
+		}),
+	);
+
+	async function replaceResultsWithPositions(
+		editor: vscode.TextEditor,
+		positionsAndExpressions: [vscode.Position, string][],
+		mode: 'append' | 'replace',
+	) {
+		await editor.edit((editBuilder) => {
+			for (const [position, expression] of positionsAndExpressions) {
+				const lineCalcResult = calcProvider.calculateLine(position, expression);
+				if (lineCalcResult == null) {
+					continue;
+				}
+				const { insertText, expressionWithEqualSignRange, expressionEndRange } =
+					lineCalcResult;
+
+				if (mode === 'append') {
+					const endWithEqual = expression.trimEnd().endsWith('=');
+					editBuilder.replace(
+						expressionEndRange,
+						endWithEqual ? insertText : ` = ${insertText}`,
+					);
+				} else if (mode === 'replace') {
+					editBuilder.replace(expressionWithEqualSignRange, insertText);
+				}
+			}
+		});
+	}
+
+	async function replaceResult(
+		mode: 'append' | 'replace',
+		withCursor: boolean,
+	) {
+		const editor = vscode.window.activeTextEditor;
+		if (!editor || !editor.selection.isEmpty) {
+			return;
+		}
+		const doc = editor.document;
+
+		let positionsAndExpressions;
+		if (withCursor) {
+			positionsAndExpressions = editor.selections.map(
+				(selection) =>
+					<[vscode.Position, string]>[
+						selection.active,
+						doc
+							.lineAt(selection.active.line)
+							.text.slice(0, selection.active.character),
+					],
+			);
+		} else {
+			const uniqueLineNumbers = [
+				...new Set(editor.selections.map((selection) => selection.active.line)),
+			];
+			positionsAndExpressions = uniqueLineNumbers.map((number) => {
+				const line = doc.lineAt(number);
+				return <[vscode.Position, string]>[line.range.end, line.text];
+			});
+		}
+		await replaceResultsWithPositions(editor, positionsAndExpressions, mode);
+	}
+
+	extensionContext.subscriptions.push(
+		vscode.commands.registerTextEditorCommand('extension.calcAppendWithCursor', () => {
+			replaceResult('append', true).catch(onError);
+		}),
+		vscode.commands.registerTextEditorCommand('extension.calcAppend', () => {
+			replaceResult('append', false).catch(onError);
+		}),
+		vscode.commands.registerTextEditorCommand(
+			'extension.calcReplaceWithCursor',
+			() => {
+				replaceResult('replace', true).catch(onError);
+			},
+		),
+		vscode.commands.registerTextEditorCommand('extension.calcReplace', () => {
+			replaceResult('replace', false).catch(onError);
+		}),
+	);
 
 	const commands = [
-		vscode.commands.registerCommand(openCommand, (uri) => {
-			if (!uri) {
-				vscode.window.showWarningMessage('The intended usage is from the explorer context menu.');
-				return;
-			}
-			vscode.window.showInformationMessage(`Opening ${uri.path} in new window!`);
-			vscode.commands.executeCommand('vscode.openFolder', uri, true);
-		}),
+		vscode.commands.registerCommand("copyHelper.copySyntaxInLight", copyHelper.copySyntaxInLight),
+		vscode.commands.registerCommand("extension.rotateExplorerSortOrder", settingsHelper.rotateExplorerSortOrder),
+		vscode.commands.registerCommand("kanban.refreshBoth", () => { kanbanHelper.refreshBoth(extensionContext); }),
+		vscode.commands.registerCommand("kanban.refreshSidebar", ColumnsToCardsWebviewViewProvider.refreshSidebar),
+		vscode.commands.registerCommand("kanban.openWithTextEditor", kanbanHelper.openWithTextEditor),
+		vscode.commands.registerCommand("kanban.openInNewWindow", kanbanHelper.openInNewWindow),
+		vscode.commands.registerCommand("markdown.newMarkdownFile", markdownHelper.newMarkdownFile),
 		vscode.commands.registerCommand('promiseLinesHelper.codeGeneratorQuickPick', promiseLinesHelper.codeGeneratorQuickPick),
+		vscode.commands.registerCommand('promiseLinesHelper.genericFileFolderHelper', promiseLinesHelper.genericFileFolderHelper),
+		vscode.commands.registerCommand('promiseLinesHelper.insertDateTime', promiseLinesHelper.insertDateTime),
+		vscode.commands.registerCommand("promiseLinesHelper.insertAllExtensions", promiseLinesHelper.insertAllExtensions),
+		vscode.commands.registerCommand('promiseLinesHelper.transformToPopperCase', promiseLinesHelper.transformToPopperCase),
+		vscode.commands.registerCommand('promiseLinesHelper.transformToParamCase', promiseLinesHelper.transformToParamCase),
 		vscode.commands.registerCommand('readOnlyLinesHelper.searchGoogle', readOnlyLinesHelper.searchGoogle),
 		vscode.commands.registerCommand('replaceLinesHelper.addCSharpComment', replaceLinesHelper.addCSharpComment),
 		vscode.commands.registerCommand('replaceLinesHelper.addVBComment', replaceLinesHelper.addVBComment),
 		vscode.commands.registerCommand('replaceLinesHelper.convertToRegularExpression', replaceLinesHelper.convertToRegularExpression),
 		vscode.commands.registerCommand('replaceLinesHelper.cutEachLine', replaceLinesHelper.cutEachLine),
+		vscode.commands.registerCommand('replaceLinesHelper.distinctLines', replaceLinesHelper.distinctLines),
 		vscode.commands.registerCommand('replaceLinesHelper.expandSql', replaceLinesHelper.expandSql),
 		vscode.commands.registerCommand('replaceLinesHelper.listToListFamily', replaceLinesHelper.listToListFamily),
 		vscode.commands.registerCommand('replaceLinesHelper.listToListWrappedComma', replaceLinesHelper.listToListWrappedComma),
@@ -55,13 +159,25 @@ export function activate(context: vscode.ExtensionContext) {
 		vscode.commands.registerCommand('replaceLinesHelper.removeComment', replaceLinesHelper.removeComment),
 		vscode.commands.registerCommand('replaceLinesHelper.sortLength', replaceLinesHelper.sortLength),
 		vscode.commands.registerCommand('replaceLinesHelper.sortNormal', replaceLinesHelper.sortNormal),
+		vscode.commands.registerCommand('replaceLinesHelper.splitBySpaceReverseJoinSort', replaceLinesHelper.splitBySpaceReverseJoinSort),
 		vscode.commands.registerCommand('replaceLinesHelper.unwrapSql', replaceLinesHelper.unwrapSql),
 		vscode.commands.registerCommand('replaceLinesHelper.wrapSqlCSharp', replaceLinesHelper.wrapSqlCSharp),
-		vscode.commands.registerCommand('replaceLinesHelper.wrapSqlVB', replaceLinesHelper.wrapSqlVB)
+		vscode.commands.registerCommand('replaceLinesHelper.wrapSqlVB', replaceLinesHelper.wrapSqlVB),
+		vscode.commands.registerCommand("webview.backlogMesa", () => { WebviewPanelCostOfDelay.WebviewPanelCostOfDelay.createOrShow(extensionContext, 'MES', 'HTML'); }),
+		vscode.commands.registerCommand("webview.costOfDelayMesa", () => { WebviewPanelCostOfDelay.WebviewPanelCostOfDelay.createOrShow(extensionContext, 'MES', ''); }),
+		vscode.commands.registerCommand("webview.costOfDelayEffortMesa", () => { WebviewPanelCostOfDelay.WebviewPanelCostOfDelay.createOrShow(extensionContext, 'MES', 'EFFORT'); }),
+		vscode.commands.registerCommand("webview.costOfDelayLiveMesa", () => { WebviewPanelCostOfDelay.WebviewPanelCostOfDelay.createOrShow(extensionContext, 'MES', 'LIVE'); }),
+		vscode.commands.registerCommand("webview.costOfDelayWSJFMesa", () => { WebviewPanelCostOfDelay.WebviewPanelCostOfDelay.createOrShow(extensionContext, 'MES', 'WSJF'); }),
+		vscode.commands.registerCommand("webview.backlogLeominster", () => { WebviewPanelCostOfDelay.WebviewPanelCostOfDelay.createOrShow(extensionContext, 'LEO', 'HTML'); }),
+		vscode.commands.registerCommand("webview.costOfDelayLeominster", () => { WebviewPanelCostOfDelay.WebviewPanelCostOfDelay.createOrShow(extensionContext, 'LEO', ''); }),
+		vscode.commands.registerCommand("webview.costOfDelayEffortLeominster", () => { WebviewPanelCostOfDelay.WebviewPanelCostOfDelay.createOrShow(extensionContext, 'LEO', 'EFFORT'); }),
+		vscode.commands.registerCommand("webview.costOfDelayLiveLeominster", () => { WebviewPanelCostOfDelay.WebviewPanelCostOfDelay.createOrShow(extensionContext, 'LEO', 'LIVE'); }),
+		vscode.commands.registerCommand("webview.costOfDelayWSJFLeominster", () => { WebviewPanelCostOfDelay.WebviewPanelCostOfDelay.createOrShow(extensionContext, 'LEO', 'WSJF'); }),
+		vscode.commands.registerCommand("webview.example", () => { WebviewPanelExample.WebviewPanelExample.createOrShow(extensionContext); })
 	];
 
-	commands.forEach(command => context.subscriptions.push(command));
+	commands.forEach(command => extensionContext.subscriptions.push(command));
 }
 
-// this method is called when your extension is deactivated
+// This method is called when your extension is deactivated
 export function deactivate() { }

type-script-helper/src/getNonce.ts

@@ -0,0 +1,9 @@
+export function getNonce() {
+  let text = "";
+  const possible =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  for (let i = 0; i < 32; i++) {
+    text += possible.charAt(Math.floor(Math.random() * possible.length));
+  }
+  return text;
+}

type-script-helper/src/kanbanHelper.ts

@@ -0,0 +1,132 @@
+import * as vscode from 'vscode';
+import { paramCase } from './promiseLinesHelper';
+import { refreshSidebar } from './ColumnsToCardsWebviewViewProvider';
+
+export function refreshBoth(extensionContext: vscode.ExtensionContext): any {
+    refreshSidebar();
+    setTimeout(() => { vscode.commands.executeCommand("workbench.action.webview.openDeveloperTools"); }, 500);
+}
+
+async function updateWithLogic(textDocument: vscode.TextDocument) {
+    await vscode.window.showTextDocument(textDocument);
+    const textEditor = vscode.window.activeTextEditor;
+    if (!textEditor) {
+        return undefined;
+    }
+    const now: Date = new Date();
+    const time: number = now.getTime();
+    const year: number = now.getFullYear();
+    const start: Date = new Date(year, 0, 0);
+    const oneDay: number = 1000 * 60 * 60 * 24;
+    const timezoneOffset: number = now.getTimezoneOffset();
+    let segments: string[] = textDocument.fileName.split('\\');
+    const diff: number = (time - start.getTime()) + ((start.getTimezoneOffset() - timezoneOffset) * 60 * 1000);
+    const day: number = Math.floor(diff / oneDay);
+    const seconds: number = time.valueOf() + timezoneOffset;
+    let notLastThree: string[] = segments.slice(0, -3);
+    let season: string = year + "-";
+    if (day < 78) {
+        season += "0.Winter";
+    } else if (day < 124) {
+        season += "1.Spring";
+    } else if (day < 171) {
+        season += "2.Spring";
+    } else if (day < 217) {
+        season += "3.Summer";
+    } else if (day < 264) {
+        season += "4.Summer";
+    } else if (day < 309) {
+        season += "5.Fall";
+    } else if (day < 354) {
+        season += "6.Fall";
+    } else {
+        season += "7.Winter";
+    }
+    let path: string = notLastThree.join('\\') + `\\${year}\\${season}\\${seconds}`;
+    const uri = vscode.Uri.parse(path);
+    textEditor.edit(editBuilder => {
+        let text: string = `\r\n## Code Insiders\r\n\r\n- [code-insiders](${path})\r\n\r\n## Sub-tasks\r\n\r\n- [ ] To do`;
+        let position: vscode.Position = new vscode.Position(textDocument.lineCount, 0);
+        editBuilder.insert(position, text);
+    });
+}
+
+async function openInNewWindowLogic(): Promise<any> {
+    if (vscode.workspace.workspaceFolders === undefined) {
+        vscode.window.showInformationMessage("Open workspace first!");
+        return;
+    }
+    if (vscode.window.tabGroups.activeTabGroup.activeTab === undefined) {
+        vscode.window.showInformationMessage("Open a tab first!");
+        return;
+    }
+    const activeTab = vscode.window.tabGroups.activeTabGroup.activeTab;
+    const tabs: vscode.Tab[] = vscode.window.tabGroups.all.map(tagGroup => tagGroup.tabs).flat();
+    const index = tabs.findIndex(tab => tab.label === activeTab.label);
+    const paramCaseActiveTabLabel: string = paramCase(activeTab.label);
+    vscode.window.showInformationMessage(`Searching for <${paramCaseActiveTabLabel}>`);
+    const fileUris: vscode.Uri[] = await vscode.workspace.findFiles(`**/${paramCaseActiveTabLabel}*`);
+    if (fileUris.length === 0) {
+        vscode.window.showInformationMessage(`Didn't find a file matching <${paramCaseActiveTabLabel}>!`);
+        return;
+    }
+    for (let i = 0; i < fileUris.length; ++i) {
+        let found: boolean = false;
+        const textDocument: vscode.TextDocument = await vscode.workspace.openTextDocument(fileUris[i]);
+        for (let j = 0; j < textDocument.lineCount; ++j) {
+            const text = textDocument.lineAt(j).text;
+            if (text.endsWith(')')) {
+                if (text.startsWith("- [code](")) {
+                    found = true;
+                    const uri = vscode.Uri.parse("file:" + text.substring(9, text.length - 1));
+                    await vscode.commands.executeCommand('vscode.openFolder', uri, true);
+                    break;
+                }
+                if (text.startsWith("- [codium](")) {
+                    found = true;
+                    const uri = vscode.Uri.parse("file:" + text.substring(11, text.length - 1));
+                    await vscode.commands.executeCommand('vscode.openFolder', uri, true);
+                    break;
+                }
+                if (text.startsWith("- [code-insiders](")) {
+                    found = true;
+                    const uri = vscode.Uri.parse("file:" + text.substring(18, text.length - 1));
+                    await vscode.commands.executeCommand('vscode.openFolder', uri, true);
+                    break;
+                }
+            }
+        }
+        if (!found) {
+            updateWithLogic(textDocument);
+        }
+        else if (index !== -1) {
+            await vscode.window.tabGroups.close(tabs[index]);
+        }
+    }
+}
+
+async function openWithTextEditorLogic(): Promise<any> {
+    if (vscode.workspace.workspaceFolders === undefined) {
+        vscode.window.showInformationMessage("Open workspace first!");
+        return;
+    }
+    if (vscode.window.tabGroups.activeTabGroup.activeTab === undefined) {
+        vscode.window.showInformationMessage("Open a tab first!");
+        return;
+    }
+    const activeTabLabel = vscode.window.tabGroups.activeTabGroup.activeTab.label;
+    const paramCaseActiveTabLabel: string = paramCase(activeTabLabel);
+    vscode.window.showInformationMessage(`Searching for <${paramCaseActiveTabLabel}>`);
+    const fileUris: vscode.Uri[] = await vscode.workspace.findFiles(`**/${paramCaseActiveTabLabel}*`);
+    if (fileUris.length === 0) {
+        vscode.window.showInformationMessage(`Didn't find a file matching <${paramCaseActiveTabLabel}>!`);
+        return;
+    }
+    for (let i = 0; i < fileUris.length; ++i) {
+        const textDocument: vscode.TextDocument = await vscode.workspace.openTextDocument(fileUris[i]);
+        await vscode.window.showTextDocument(textDocument);
+    }
+}
+
+export const openInNewWindow = () => openInNewWindowLogic();
+export const openWithTextEditor = () => openWithTextEditorLogic();

type-script-helper/src/markdownHelper.ts

@@ -0,0 +1,22 @@
+import * as vscode from 'vscode';
+import { paramCase } from './promiseLinesHelper';
+
+async function newMarkdownFileLogic(): Promise<any> {
+    console.log(vscode.window.tabGroups.activeTabGroup.activeTab?.label);
+    if (vscode.workspace.workspaceFolders === undefined) {
+        vscode.window.showInformationMessage("Open workspace first!");
+        return;
+    }
+    const workspaceFoldersZero = vscode.workspace.workspaceFolders[0].uri;
+    const cardTitle = await vscode.window.showInputBox({ prompt: 'Provide title for card.' });
+    if (cardTitle === undefined)
+        return;
+    const paramCaseCardTitle: string = paramCase(cardTitle);
+    const fileUri: vscode.Uri = vscode.Uri.joinPath(workspaceFoldersZero, `${paramCaseCardTitle}.md`);
+    const buffer: Buffer = Buffer.from(`# ${cardTitle}`, 'utf8');
+    await vscode.workspace.fs.writeFile(fileUri, buffer);
+    const textDocument: vscode.TextDocument = await vscode.workspace.openTextDocument(fileUri);
+    vscode.window.showTextDocument(textDocument);
+}
+
+export const newMarkdownFile = () => newMarkdownFileLogic();

type-script-helper/src/promiseLinesHelper.ts

@@ -1,5 +1,4 @@
 import * as vscode from 'vscode';
-import { QuickPickItem } from "vscode";
 
 function codeGeneratorQuickPickLogic(): undefined {
     const textEditor = vscode.window.activeTextEditor;
@@ -87,7 +86,7 @@ function codeGeneratorQuickPickLogic(): undefined {
             }, {
                 label: "Path without Brackets (Singularized)",
                 detail: "",
-                output: "%PathWithoutBracketSingularized%"
+                output: "%PathWithoutBracketsSingularized%"
             }, {
                 label: "Suggested Type",
                 detail: "Type based on values in *.json file",
@@ -129,4 +128,176 @@ function codeGeneratorQuickPickLogic(): undefined {
     return undefined;
 }
 
-export const codeGeneratorQuickPick = () => codeGeneratorQuickPickLogic();
+function insertDateTimeLogic(): undefined {
+    const textEditor = vscode.window.activeTextEditor;
+    if (!textEditor) {
+        return undefined;
+    }
+    const selection = textEditor.selection;
+    textEditor.edit(editBuilder => {
+        var range;
+        const now: Date = new Date();
+        const time: number = now.getTime();
+        const year: number = now.getFullYear();
+        const start: Date = new Date(year, 0, 0);
+        const oneDay: number = 1000 * 60 * 60 * 24;
+        const timezoneOffset: number = now.getTimezoneOffset();
+        const diff: number = (time - start.getTime()) + ((start.getTimezoneOffset() - timezoneOffset) * 60 * 1000);
+        const seconds: number = time.valueOf() + timezoneOffset;
+        const day: number = Math.floor(diff / oneDay);
+        const epoch: number = seconds * 10000;
+        const ticks: number = epoch + 621355968000000000;
+        let season: string = year + "-";
+        if (day < 78) {
+            season += "0.Winter";
+        } else if (day < 124) {
+            season += "1.Spring";
+        } else if (day < 171) {
+            season += "2.Spring";
+        } else if (day < 217) {
+            season += "3.Summer";
+        } else if (day < 264) {
+            season += "4.Summer";
+        } else if (day < 309) {
+            season += "5.Fall";
+        } else if (day < 354) {
+            season += "6.Fall";
+        } else {
+            season += "7.Winter";
+        }
+        const dateText = seconds + " = " + ticks + " = " + season + " = " + now.toString();
+        if (selection.isEmpty) {
+            editBuilder.insert(selection.start, dateText)
+        }
+        else {
+            range = new vscode.Range(selection.start.line, selection.start.character, selection.end.line, selection.end.character);
+            editBuilder.replace(range, dateText);
+        }
+    });
+    return undefined;
+}
+
+function insertAllExtensionsLogic(): undefined {
+    const textEditor = vscode.window.activeTextEditor;
+    if (!textEditor) {
+        return undefined;
+    }
+    const selection = textEditor.selection;
+    textEditor.edit(editBuilder => {
+        var range;
+        let extensions = vscode.extensions.all;
+        let text = extensions.map(extension => extension.id).join("\n");
+        if (selection.isEmpty) {
+            editBuilder.insert(selection.start, text)
+        }
+        else {
+            range = new vscode.Range(selection.start.line, selection.start.character, selection.end.line, selection.end.character);
+            editBuilder.replace(range, text);
+        }
+    });
+    return undefined;
+}
+
+function genericFileFolderHelperLogic(): undefined {
+    const textEditor = vscode.window.activeTextEditor;
+    if (!textEditor) {
+        vscode.window.showInformationMessage("Open a text editor first!");
+        return undefined;
+    }
+    else {
+        const selection = textEditor.selection;
+        if (selection.isEmpty) {
+            vscode.window.showInformationMessage("Highlight text to pass first!");
+            return undefined;
+        }
+        let range = new vscode.Range(selection.start, selection.end)
+        let text = textEditor.document.getText(range);
+        if (vscode.workspace.workspaceFolders === undefined) {
+            vscode.window.showInformationMessage("Open workspace first!");
+            return undefined;
+        }
+        const workspaceFoldersZero = vscode.workspace.workspaceFolders[0].uri;
+        const jsonFile: vscode.Uri = vscode.Uri.joinPath(workspaceFoldersZero, ".vscode", "helper", ".json");
+        let data = {
+            workspaceFoldersZero: workspaceFoldersZero.path,
+            text: text,
+        };
+        let json = JSON.stringify(data);
+        const buffer: Buffer = Buffer.from(json, 'utf8');
+        vscode.workspace.fs.writeFile(jsonFile, buffer);
+        textEditor.edit(editBuilder => {
+            let range = new vscode.Range(selection.start.line, selection.start.character, selection.end.line, selection.end.character);
+            editBuilder.replace(range, "");
+        });
+        textEditor.document.save();
+    }
+    return undefined;
+}
+
+function camelCase(str: string) {
+    return str.replace(/(?:^\w|[A-Z]|\b\w|\s+)/g, function (match, index) {
+        if (+match === 0) return "";
+        return index === 0 ? match.toLowerCase() : match.toUpperCase();
+    });
+}
+
+function transformToPopperCaseLogic(): undefined {
+    const textEditor = vscode.window.activeTextEditor;
+    if (!textEditor) {
+        return undefined;
+    }
+    const selection = textEditor.selection;
+    textEditor.edit(editBuilder => {
+        var range;
+        if (selection.isEmpty) {
+            return undefined;
+        }
+        else {
+            range = new vscode.Range(selection.start.line, selection.start.character, selection.end.line, selection.end.character);
+            const highlighted = textEditor.document.getText(range);
+            let camelCased = camelCase(highlighted);
+            let properCased = camelCased.substring(0, 1).toUpperCase() + camelCased.substring(1, camelCased.length);
+            editBuilder.replace(range, properCased);
+        }
+    });
+    return undefined;
+}
+
+export function paramCase(str: string) {
+    return str
+        .replace(
+            /([A-Z]+(.))/g,
+            (_, separator, letter, offset) => (offset ? "-" + separator : separator).toLowerCase()
+        )
+        .split(/[\s!?.,@:;|\\/"'`£$%\^&*{}[\]()<>~#+\-=_¬]+/g)
+        .join('-')
+        .replace(/(^-|-$)/g, '');
+};
+
+function transformToParamCaseLogic(): undefined {
+    const textEditor = vscode.window.activeTextEditor;
+    if (!textEditor) {
+        return undefined;
+    }
+    const selection = textEditor.selection;
+    textEditor.edit(editBuilder => {
+        var range;
+        if (selection.isEmpty) {
+            return undefined;
+        }
+        else {
+            range = new vscode.Range(selection.start.line, selection.start.character, selection.end.line, selection.end.character);
+            const highlighted = textEditor.document.getText(range);
+            let paramCased = paramCase(highlighted);
+            editBuilder.replace(range, paramCased);
+        }
+    });
+    return undefined;
+}
+
+export const codeGeneratorQuickPick = () => codeGeneratorQuickPickLogic();
+export const genericFileFolderHelper = () => genericFileFolderHelperLogic();
+export const insertDateTime = () => insertDateTimeLogic();
+export const insertAllExtensions = () => insertAllExtensionsLogic();
+export const transformToPopperCase = () => transformToPopperCaseLogic();
+export const transformToParamCase = () => transformToParamCaseLogic();

type-script-helper/src/replaceLinesHelper.ts

@@ -8,6 +8,7 @@ enum LinesAction {
     addVBComment,
     convertToRegularExpression,
     cutEachLine,
+    distinctLines,
     expandSql,
     listToListFamily,
     listToListWrappedComma,
@@ -21,6 +22,7 @@ enum LinesAction {
     removeComment,
     sortLength,
     sortNormal,
+    splitBySpaceReverseJoinSort,
     unwrapSql,
     wrapSqlCSharp,
     wrapSqlVB
@@ -150,7 +152,7 @@ function prettySqlLogic(lines: string[]): void {
 }
 
 function camelCase(str: string) {
-    return str.replace(/(?:^\w|[A-Z]|\b\w|\s+)/g, function(match, index) {
+    return str.replace(/(?:^\w|[A-Z]|\b\w|\s+)/g, function (match, index) {
         if (+match === 0) return "";
         return index === 0 ? match.toLowerCase() : match.toUpperCase();
     });
@@ -168,7 +170,7 @@ function capitalize(word: string) {
 function quickFixCamelCasePropertiesLogic(lines: string[]): void {
     for (let i = 0; i < lines.length; ++i) {
         let segments = lines[i].trim().split(' ');
-        if(segments.length < 2 || segments.length > 3)
+        if (segments.length < 2 || segments.length > 3)
             continue;
         let leftPadding = lines[i].substring(0, lines[i].indexOf(segments[0]));
         if (segments.length === 2) segments = ('protected ' + lines[i].trim()).split(' ');
@@ -181,7 +183,7 @@ function quickFixCamelCasePropertiesLogic(lines: string[]): void {
 function quickFixCS0108Logic(lines: string[]): void {
     for (let i = 0; i < lines.length; ++i) {
         let segments = lines[i].trim().split(' ');
-        if(segments.length < 2 || segments.length > 3)
+        if (segments.length < 2 || segments.length > 3)
             continue;
         let leftPadding = lines[i].substring(0, lines[i].indexOf(segments[0]));
         if (segments.length === 2) segments = ('protected ' + lines[i].trim()).split(' ');
@@ -196,15 +198,15 @@ function quickFixCS0108Logic(lines: string[]): void {
 function quickFixInstanceFieldToCalisthenicsLogic(lines: string[]): void {
     for (let i = 0; i < lines.length; ++i) {
         let segments = lines[i].trim().split(' ');
-        if(segments.length !== 2)
+        if (segments.length !== 2)
             continue;
         let leftPadding = lines[i].substring(0, lines[i].indexOf(segments[0]));
         let type = segments[0];
         let name = segments[1].split(';')[0];
-        let singularName = name;        
-        if(name[name.length - 1] === 's') {
-            if(name[name.length - 2] === 'e') {                
-                if(name[name.length - 3] === 'i') {
+        let singularName = name;
+        if (name[name.length - 1] === 's') {
+            if (name[name.length - 2] === 'e') {
+                if (name[name.length - 3] === 'i') {
                     singularName = name.substring(0, singularName.length - 3) + 'y';
                 }
                 else
@@ -214,11 +216,11 @@ function quickFixInstanceFieldToCalisthenicsLogic(lines: string[]): void {
                 singularName = name.substring(0, singularName.length - 1);
         }
         segments = type.split('<');
-        if(segments.length === 2)
+        if (segments.length === 2)
             lines[i] = leftPadding + 'public ' + segments[0] + '<' + singularName + '> ' + name + ' { get; } //' + segments[1].split('>')[0];
         else {
             segments = type.split('[');
-            if(segments.length === 2)
+            if (segments.length === 2)
                 lines[i] = leftPadding + 'public ' + singularName + '[] ' + name + ' { get; } //' + segments[0];
             else
                 lines[i] = leftPadding + 'public ' + singularName + ' ' + name + ' { get; } //' + type;
@@ -230,7 +232,7 @@ function quickFixInstanceFieldToCalisthenicsLogic(lines: string[]): void {
 function quickFixProperCasePropertiesLogic(lines: string[]): void {
     for (let i = 0; i < lines.length; ++i) {
         let segments = lines[i].trim().split(' ');
-        if(segments.length < 2 || segments.length > 3)
+        if (segments.length < 2 || segments.length > 3)
             continue;
         let leftPadding = lines[i].substring(0, lines[i].indexOf(segments[0]));
         if (segments.length === 2) segments = ('protected ' + lines[i].trim()).split(' ');
@@ -244,7 +246,7 @@ function quickFixProperCasePropertiesLogic(lines: string[]): void {
 function quickFixPublicLogic(lines: string[]): void {
     for (let i = 0; i < lines.length; ++i) {
         let segments = lines[i].trim().split(' ');
-        if(segments.length < 2 || segments.length > 3)
+        if (segments.length < 2 || segments.length > 3)
             continue;
         let leftPadding = lines[i].substring(0, lines[i].indexOf(segments[0]));
         if (segments.length === 2) segments = ('protected ' + lines[i].trim()).split(' ');
@@ -282,6 +284,23 @@ function sortNormalLogic(lines: string[]): void {
     lines = transformers.reduce((currentLines, transform) => transform(currentLines), lines);
 }
 
+function splitBySpaceReverseJoinSortLogic(lines: string[]): void {
+    var transformers: ArrayTransformer[] = [];
+    transformers.push(makeSorter());
+
+    for (let i = 0; i < lines.length; ++i) {
+        lines[i] = lines[i].split(' ').reverse().join(' ');
+    }
+
+    removeBlanks(lines);
+
+    lines = transformers.reduce((currentLines, transform) => transform(currentLines), lines);
+
+    for (let i = 0; i < lines.length; ++i) {
+        lines[i] = lines[i].split(' ').reverse().join(' ');
+    }
+}
+
 function unwrapSqlLogic(lines: string[]): void {
     for (let i = 0; i < lines.length; ++i) {
         lines[i] = "//" + lines[i].
@@ -347,6 +366,15 @@ function cutEachLineLogic(lines: string[]): void {
     removeBlanks(lines);
 }
 
+function distinctLinesLogic(lines: string[]): void {
+    for (let i = 0; i < lines.length; ++i) {
+        if (lines[i].trim() === '' || lines.indexOf(lines[i]) !== lines.lastIndexOf(lines[i])) {
+            lines.splice(i, 1);
+            i--;
+        }
+    }
+}
+
 function returnLines(textEditor: vscode.TextEditor, startLine: number, endLine: number, lines: string[]) {
     return textEditor.edit(editBuilder => {
         const range = new vscode.Range(startLine, 0, endLine, textEditor.document.lineAt(endLine).text.length);
@@ -372,6 +400,7 @@ function linesFunction(linesAction: LinesAction): Thenable<boolean> | undefined
         case LinesAction.addVBComment: { addVBCommentLogic(lines); break; }
         case LinesAction.convertToRegularExpression: { lines = convertToRegularExpressionLogic(lines); break; }
         case LinesAction.cutEachLine: { cutEachLineLogic(lines); break; }
+        case LinesAction.distinctLines: { distinctLinesLogic(lines); break; }
         case LinesAction.expandSql: { expandSqlLogic(lines); break; }
         case LinesAction.listToListFamily: { listToListFamilyLogic(lines); break; }
         case LinesAction.listToListWrappedComma: { listToListWrappedCommaLogic(lines); break; }
@@ -384,6 +413,7 @@ function linesFunction(linesAction: LinesAction): Thenable<boolean> | undefined
         case LinesAction.removeComment: { removeCommentLogic(lines); break; }
         case LinesAction.sortLength: { sortLengthLogic(lines); break; }
         case LinesAction.sortNormal: { sortNormalLogic(lines); break; }
+        case LinesAction.splitBySpaceReverseJoinSort: { splitBySpaceReverseJoinSortLogic(lines); break; }
         case LinesAction.unwrapSql: { unwrapSqlLogic(lines); break; }
         case LinesAction.wrapSqlCSharp: { wrapSqlCSharpLogic(lines); break; }
         case LinesAction.wrapSqlVB: { wrapSqlVBLogic(lines); break; }
@@ -396,6 +426,7 @@ export const addCSharpComment = () => linesFunction(LinesAction.addCSharpComment
 export const addVBComment = () => linesFunction(LinesAction.addVBComment);
 export const convertToRegularExpression = () => linesFunction(LinesAction.convertToRegularExpression);
 export const cutEachLine = () => linesFunction(LinesAction.cutEachLine);
+export const distinctLines = () => linesFunction(LinesAction.distinctLines);
 export const expandSql = () => linesFunction(LinesAction.expandSql);
 export const listToListFamily = () => linesFunction(LinesAction.listToListFamily);
 export const listToListWrappedComma = () => linesFunction(LinesAction.listToListWrappedComma);
@@ -409,6 +440,7 @@ export const pdsfToFixedWidth = () => linesFunction(LinesAction.pdsfToFixedWidth
 export const removeComment = () => linesFunction(LinesAction.removeComment);
 export const sortLength = () => linesFunction(LinesAction.sortLength);
 export const sortNormal = () => linesFunction(LinesAction.sortNormal);
+export const splitBySpaceReverseJoinSort = () => linesFunction(LinesAction.splitBySpaceReverseJoinSort);
 export const unwrapSql = () => linesFunction(LinesAction.unwrapSql);
 export const wrapSqlCSharp = () => linesFunction(LinesAction.wrapSqlCSharp);
 export const wrapSqlVB = () => linesFunction(LinesAction.wrapSqlVB);

type-script-helper/src/settingsHelper.ts

@@ -0,0 +1,29 @@
+import * as vscode from 'vscode';
+
+async function rotateExplorerSortOrderLogic(): Promise<any> {
+    const config = vscode.workspace.getConfiguration("explorer");
+    const sortOrder = config.get("sortOrder");
+    let sortOrderOptions = [
+        "default",
+        "modified",
+        "type",
+        "mixed",
+        "filesFirst",
+        "foldersNestsFiles",
+    ];
+    let index = sortOrderOptions.findIndex(l => l === sortOrder);
+    if (index !== -1)
+        index++;
+    else
+        index = 0;
+    if (index >= sortOrderOptions.length)
+        index = 0;
+    let value = sortOrderOptions[index];
+    await config.update("sortOrder", value);
+    index++;    
+    if (index >= sortOrderOptions.length)
+        index = 0;
+    vscode.window.showInformationMessage(`Explorer Sort Order set to: ${value}; next will be: ${sortOrderOptions[index]};`);
+}
+
+export const rotateExplorerSortOrder = () => rotateExplorerSortOrderLogic();

type-script-helper/src/test/runTest.ts

@@ -1,23 +0,0 @@
-import * as path from 'path';
-
-import { runTests } from 'vscode-test';
-
-async function main() {
-	try {
-		// The folder containing the Extension Manifest package.json
-		// Passed to `--extensionDevelopmentPath`
-		const extensionDevelopmentPath = path.resolve(__dirname, '../../');
-
-		// The path to test runner
-		// Passed to --extensionTestsPath
-		const extensionTestsPath = path.resolve(__dirname, './suite/index');
-
-		// Download VS Code, unzip it and run the integration test
-		await runTests({ extensionDevelopmentPath, extensionTestsPath });
-	} catch (err) {
-		console.error('Failed to run tests');
-		process.exit(1);
-	}
-}
-
-main();

type-script-helper/src/test/suite/extension.test.ts

@@ -1,15 +0,0 @@
-import * as assert from 'assert';
-
-// You can import and use all API from the 'vscode' module
-// as well as import your extension to test it
-import * as vscode from 'vscode';
-// import * as myExtension from '../extension';
-
-suite('Extension Test Suite', () => {
-	vscode.window.showInformationMessage('Start all tests.');
-
-	test('Sample test', () => {
-		assert.equal(-1, [1, 2, 3].indexOf(5));
-		assert.equal(-1, [1, 2, 3].indexOf(0));
-	});
-});

type-script-helper/src/test/suite/index.ts

@@ -1,37 +0,0 @@
-import * as path from 'path';
-import * as Mocha from 'mocha';
-import * as glob from 'glob';
-
-export function run(): Promise<void> {
-	// Create the mocha test
-	const mocha = new Mocha({
-		ui: 'tdd',
-	});
-	mocha.useColors(true);
-
-	const testsRoot = path.resolve(__dirname, '..');
-
-	return new Promise((c, e) => {
-		glob('**/**.test.js', { cwd: testsRoot }, (err, files) => {
-			if (err) {
-				return e(err);
-			}
-
-			// Add files to the test suite
-			files.forEach(f => mocha.addFile(path.resolve(testsRoot, f)));
-
-			try {
-				// Run the mocha test
-				mocha.run(failures => {
-					if (failures > 0) {
-						e(new Error(`${failures} tests failed.`));
-					} else {
-						c();
-					}
-				});
-			} catch (err) {
-				e(err);
-			}
-		});
-	});
-}

type-script-helper/tsconfig.json

@@ -1,22 +1,19 @@
 {
 	"compilerOptions": {
-		"module": "commonjs",
-		"target": "es6",
-		"outDir": "out",
+		"typeRoots": ["./node_modules/@types"],
+		"allowSyntheticDefaultImports": true,
 		"lib": [
-			"es6"
+			"ES2020"
 		],
-		"sourceMap": true,
+		"module": "commonjs",
 		"rootDir": "src",
-		"resolveJsonModule": true,
-		"strict": true   /* enable all strict type-checking options */
-		/* Additional Checks */
-		// "noImplicitReturns": true, /* Report error when not all code paths in function return a value. */
-		// "noFallthroughCasesInSwitch": true, /* Report errors for fallthrough cases in switch statement. */
-		// "noUnusedParameters": true,  /* Report errors on unused parameters. */
+		"sourceMap": true,
+		"strict": true,
+		"target": "ES2020"
 	},
 	"exclude": [
 		"node_modules",
-		".vscode-test"
+		".vscode-test",
+		"webviews"
 	]
-}
+}

type-script-helper/tslint.json

@@ -1,15 +0,0 @@
-{
-	"rules": {
-		"no-string-throw": true,
-		"no-unused-expression": true,
-		"no-duplicate-variable": true,
-		"curly": true,
-		"class-name": true,
-		"semicolon": [
-			true,
-			"always"
-		],
-		"triple-equals": true
-	},
-	"defaultSeverity": "warning"
-}

type-script-helper/vsc-extension-quickstart.md

@@ -1,3 +1,11 @@
+---
+type: "note"
+created: "2023-07-07T16:15:27.822Z"
+updated: "2023-07-07T16:15:27.822Z"
+---
+
+# vsc-extension-quickstart
+
 # Welcome to your VS Code Extension
 
 ## What's in the folder
@@ -9,6 +17,11 @@
   * The file exports one function, `activate`, which is called the very first time your extension is activated (in this case by executing the command). Inside the `activate` function we call `registerCommand`.
   * We pass the function containing the implementation of the command as the second parameter to `registerCommand`.
 
+## Setup
+
+* install the recommended extensions (amodio.tsl-problem-matcher and dbaeumer.vscode-eslint)
+
+
 ## Get up and running straight away
 
 * Press `F5` to open a new window with your extension loaded.
@@ -37,6 +50,6 @@
 
 ## Go further
 
- * Reduce the extension size and improve the startup time by [bundling your extension](https://code.visualstudio.com/api/working-with-extensions/bundling-extension).
- * [Publish your extension](https://code.visualstudio.com/api/working-with-extensions/publishing-extension) on the VSCode extension marketplace.
- * Automate builds by setting up [Continuous Integration](https://code.visualstudio.com/api/working-with-extensions/continuous-integration).
+* Reduce the extension size and improve the startup time by [bundling your extension](https://code.visualstudio.com/api/working-with-extensions/bundling-extension).
+* [Publish your extension](https://code.visualstudio.com/api/working-with-extensions/publishing-extension) on the VS Code extension marketplace.
+* Automate builds by setting up [Continuous Integration](https://code.visualstudio.com/api/working-with-extensions/continuous-integration).

type-script-helper/webviews/components/CardComponent.svelte

@@ -0,0 +1,25 @@
+<script lang="ts">
+  import type { Card } from "../../src/Card";
+
+  export let key: string;
+  export let card: Card;
+  export let index: number;
+</script>
+
+<!-- svelte-ignore a11y-click-events-have-key-events -->
+<!-- svelte-ignore missing-declaration -->
+<li id={index.toString()}>
+  <!-- svelte-ignore a11y-invalid-attribute -->
+  <a
+    href="#{index.toString()}"
+    title="{key}"
+    on:click={async () => {
+      acquiredVsCodeApi.postMessage({
+        type: "open-card",
+        value: { File: card.File },
+      });
+    }}
+  >
+    {card.H1}
+  </a>
+</li>

type-script-helper/webviews/components/Cards.svelte

@@ -0,0 +1,19 @@
+<script lang="ts">
+  import type { Card } from "../../src/Card";
+  import CardComponent from "./CardComponent.svelte";
+
+  export let key: string = "";
+  export let value: Array<Card> = [];
+</script>
+
+{#if !value}
+  <div>loading...</div>
+{:else}
+  <hr>
+  <h1>{key}</h1>
+  <ul>
+    {#each value as card, index}
+      <CardComponent {key} {card} {index} />
+    {/each}
+  </ul>
+{/if}

type-script-helper/webviews/components/ColumnsToCards.svelte

@@ -0,0 +1,33 @@
+<script lang="ts">
+  import { onMount } from "svelte";
+  import Cards from "./Cards.svelte";
+  import type { Card } from "../../src/Card";
+  import type { PostMessage } from "../../src/PostMessage";
+
+  let columnsToCards: Record<string, Array<Card>> = {};
+
+  onMount(async () => {
+    window.addEventListener("message", async (event) => {
+      const postMessage: PostMessage = event.data;
+      switch (postMessage.type) {
+        case "columns-to-cards": {
+          columnsToCards = postMessage.value;
+          break;
+        }
+      }
+    });
+    const postMessage: PostMessage = {
+      type: "get-columns-to-cards",
+      value: undefined,
+    };
+    acquiredVsCodeApi.postMessage(postMessage);
+  });
+</script>
+
+{#if Object.entries(columnsToCards).length == 0}
+  <div>loading...</div>
+{:else}
+  {#each Object.entries(columnsToCards) as [key, value], index (key)}
+    <Cards {key} {value} />
+  {/each}
+{/if}

type-script-helper/webviews/components/DisplayDate.svelte

@@ -0,0 +1,4 @@
+<script lang="ts">
+</script>
+
+<h1>2023-09-23-15-20</h1>

type-script-helper/webviews/globals.d.ts

@@ -0,0 +1,10 @@
+import * as _vscode from "vscode";
+import type { PostMessage } from "../types";
+
+declare global {
+  const acquiredVsCodeApi: {
+    postMessage: (PostMessage) => void;
+    getState: () => any;
+    setState: (state: any) => void;
+  };
+}

type-script-helper/webviews/pages/ColumnsToCards.ts

@@ -0,0 +1,7 @@
+import App from "../components/ColumnsToCards.svelte";
+
+const app = new App({
+  target: document.body,
+});
+
+export default app;

type-script-helper/webviews/pages/DisplayDate.ts

@@ -0,0 +1,7 @@
+import App from "../components/DisplayDate.svelte";
+
+const app = new App({
+  target: document.body,
+});
+
+export default app;

type-script-helper/webviews/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "ignoreDeprecations": "5.0",
+    "strict": true
+  },
+  "exclude": [
+    "../node_modules/*"
+  ],
+  "extends": "@tsconfig/svelte/tsconfig.json",
+  "include": [
+    "./**/*"
+  ]
+}