com.wallstop-studios.dxmessaging 2.1.4 → 2.1.6

package/mkdocs.yml.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: a29083144fb73e44980c72cf2ef01592
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "com.wallstop-studios.dxmessaging",
-  "version": "2.1.4",
+  "version": "2.1.6",
   "displayName": "DxMessaging",
   "description": "Synchronous Event Bus for Unity",
   "unity": "2021.3",
-  "documentationUrl": "Docs/Index.md",
+  "documentationUrl": "https://wallstop.github.io/DxMessaging/",
   "changelogUrl": "https://github.com/wallstop/DxMessaging/blob/master/CHANGELOG.md",
   "licensesUrl": "https://github.com/wallstop/DxMessaging/blob/master/LICENSE.md",
-  "dependencies": {},
   "keywords": [
     "messaging",
     "message",
@@ -32,7 +31,9 @@
   "homepage": "https://github.com/wallstop/DxMessaging#readme",
   "main": "README.md",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
     "format:md": "prettier --write \"**/*.{md,markdown}\"",
     "format:md:check": "prettier --check \"**/*.{md,markdown}\"",
     "format:json": "prettier --write \"**/*.{json,asmdef,asmref}\"",
@@ -43,8 +44,9 @@
     "lint:markdown": "markdownlint-cli2 \"**/*.md\" \"**/*.markdown\""
   },
   "devDependencies": {
-    "markdownlint-cli2": "^0.18.1",
-    "prettier": "3.6.2"
+    "jest": "^30.2.0",
+    "markdownlint-cli2": "^0.20.0",
+    "prettier": "3.8.1"
   },
   "samples": [
     {

package/requirements-docs.txt

@@ -0,0 +1,23 @@
+# MkDocs core
+mkdocs>=1.6.0
+
+# Theme
+mkdocs-material>=9.5.0
+mkdocs-material-extensions>=1.3.1
+
+# Plugins
+mkdocs-minify-plugin>=0.8.0
+mkdocs-git-revision-date-localized-plugin>=1.2.4
+
+# Code highlighting
+pygments>=2.17.0
+
+# Image processing for social cards (optional)
+pillow>=10.2.0
+cairosvg>=2.7.1
+
+# Markdown extensions (included with mkdocs-material, listed for completeness)
+pymdown-extensions>=10.7.0
+
+# Version management (optional, for future versioned docs)
+mike>=2.0.0

package/requirements-docs.txt.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 05b775e2fa943bb4781d996449bb1588
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/scripts/__tests__/generate-skills-index.test.js

@@ -0,0 +1,397 @@
+/**
+ * @fileoverview Tests for generate-skills-index.js logic.
+ *
+ * These tests validate the core logic of the skills index generator:
+ * - Brand name capitalization (BRAND_NAMES mapping)
+ * - Category title formatting (categoryToTitle function)
+ * - YAML frontmatter parsing
+ * - Edge cases for various inputs
+ */
+
+"use strict";
+
+const {
+    applyBrandCapitalization,
+    categoryToTitle,
+    BRAND_NAMES,
+} = require('../generate-skills-index.js');
+
+describe("generate-skills-index", () => {
+    describe("BRAND_NAMES mapping", () => {
+        test("should contain expected number of brand entries", () => {
+            const brandCount = Object.keys(BRAND_NAMES).length;
+            expect(brandCount).toBeGreaterThan(30);
+        });
+
+        test("should have all lowercase keys", () => {
+            for (const key of Object.keys(BRAND_NAMES)) {
+                expect(key).toBe(key.toLowerCase());
+            }
+        });
+
+        test("should have non-empty values for all keys", () => {
+            for (const value of Object.values(BRAND_NAMES)) {
+                expect(value).toBeTruthy();
+                expect(typeof value).toBe("string");
+            }
+        });
+    });
+
+    describe("applyBrandCapitalization", () => {
+        describe("known brand names", () => {
+            test("should return GitHub for github", () => {
+                expect(applyBrandCapitalization("github")).toBe("GitHub");
+            });
+
+            test("should return npm for npm (lowercase brand)", () => {
+                expect(applyBrandCapitalization("npm")).toBe("npm");
+            });
+
+            test("should return API for api", () => {
+                expect(applyBrandCapitalization("api")).toBe("API");
+            });
+
+            test("should return JavaScript for javascript", () => {
+                expect(applyBrandCapitalization("javascript")).toBe("JavaScript");
+            });
+
+            test("should return TypeScript for typescript", () => {
+                expect(applyBrandCapitalization("typescript")).toBe("TypeScript");
+            });
+
+            test("should return Node.js for nodejs", () => {
+                expect(applyBrandCapitalization("nodejs")).toBe("Node.js");
+            });
+
+            test("should return C# for csharp", () => {
+                expect(applyBrandCapitalization("csharp")).toBe("C#");
+            });
+
+            test("should return .NET for dotnet", () => {
+                expect(applyBrandCapitalization("dotnet")).toBe(".NET");
+            });
+
+            test("should return VS Code for vscode", () => {
+                expect(applyBrandCapitalization("vscode")).toBe("VS Code");
+            });
+
+            test("should return macOS for macos", () => {
+                expect(applyBrandCapitalization("macos")).toBe("macOS");
+            });
+
+            test("should return iOS for ios", () => {
+                expect(applyBrandCapitalization("ios")).toBe("iOS");
+            });
+
+            test("should return GraphQL for graphql", () => {
+                expect(applyBrandCapitalization("graphql")).toBe("GraphQL");
+            });
+
+            test("should return LLM for llm", () => {
+                expect(applyBrandCapitalization("llm")).toBe("LLM");
+            });
+
+            test("should return CI for ci", () => {
+                expect(applyBrandCapitalization("ci")).toBe("CI");
+            });
+
+            test("should return CD for cd", () => {
+                expect(applyBrandCapitalization("cd")).toBe("CD");
+            });
+        });
+
+        describe("case-insensitive input", () => {
+            test("should handle GITHUB (all uppercase)", () => {
+                expect(applyBrandCapitalization("GITHUB")).toBe("GitHub");
+            });
+
+            test("should handle GitHub (mixed case)", () => {
+                expect(applyBrandCapitalization("GitHub")).toBe("GitHub");
+            });
+
+            test("should handle NPM (all uppercase)", () => {
+                expect(applyBrandCapitalization("NPM")).toBe("npm");
+            });
+
+            test("should handle API (already uppercase)", () => {
+                expect(applyBrandCapitalization("API")).toBe("API");
+            });
+
+            test("should handle JavaScript (mixed case)", () => {
+                expect(applyBrandCapitalization("JavaScript")).toBe("JavaScript");
+            });
+
+            test("should handle VSCODE (all uppercase)", () => {
+                expect(applyBrandCapitalization("VSCODE")).toBe("VS Code");
+            });
+        });
+
+        describe("unknown words - standard title case", () => {
+            test("should title-case unknown word", () => {
+                expect(applyBrandCapitalization("unknown")).toBe("Unknown");
+            });
+
+            test("should title-case testing", () => {
+                expect(applyBrandCapitalization("testing")).toBe("Testing");
+            });
+
+            test("should title-case documentation", () => {
+                expect(applyBrandCapitalization("documentation")).toBe("Documentation");
+            });
+
+            test("should title-case scripting", () => {
+                expect(applyBrandCapitalization("scripting")).toBe("Scripting");
+            });
+
+            test("should title-case actions", () => {
+                expect(applyBrandCapitalization("actions")).toBe("Actions");
+            });
+
+            test("should convert UPPERCASE unknown to title case", () => {
+                expect(applyBrandCapitalization("TESTING")).toBe("Testing");
+            });
+
+            test("should convert MixedCase unknown to title case", () => {
+                expect(applyBrandCapitalization("TeStiNg")).toBe("Testing");
+            });
+        });
+
+        describe("edge cases", () => {
+            test("should handle empty string", () => {
+                const result = applyBrandCapitalization("");
+                expect(result).toBe("");
+            });
+
+            test("should handle single character lowercase", () => {
+                expect(applyBrandCapitalization("a")).toBe("A");
+            });
+
+            test("should handle single character uppercase", () => {
+                expect(applyBrandCapitalization("A")).toBe("A");
+            });
+
+            test("should handle two-letter word", () => {
+                expect(applyBrandCapitalization("ab")).toBe("Ab");
+            });
+
+            test("should handle word with numbers", () => {
+                expect(applyBrandCapitalization("test123")).toBe("Test123");
+            });
+
+            test("should handle number-only string", () => {
+                expect(applyBrandCapitalization("123")).toBe("123");
+            });
+
+            test("should handle word starting with number", () => {
+                expect(applyBrandCapitalization("3d")).toBe("3d");
+            });
+
+            test("should handle already-capitalized unknown word", () => {
+                expect(applyBrandCapitalization("Already")).toBe("Already");
+            });
+        });
+    });
+
+    describe("categoryToTitle", () => {
+        describe("single-word categories", () => {
+            test("should format testing category", () => {
+                expect(categoryToTitle("testing")).toBe("Testing");
+            });
+
+            test("should format documentation category", () => {
+                expect(categoryToTitle("documentation")).toBe("Documentation");
+            });
+
+            test("should format scripting category", () => {
+                expect(categoryToTitle("scripting")).toBe("Scripting");
+            });
+
+            test("should format github as brand name", () => {
+                expect(categoryToTitle("github")).toBe("GitHub");
+            });
+
+            test("should format api as brand name", () => {
+                expect(categoryToTitle("api")).toBe("API");
+            });
+
+            test("should format npm as brand name", () => {
+                expect(categoryToTitle("npm")).toBe("npm");
+            });
+
+            test("should format javascript as brand name", () => {
+                expect(categoryToTitle("javascript")).toBe("JavaScript");
+            });
+        });
+
+        describe("multi-word categories (hyphenated)", () => {
+            test("should format github-actions with brand capitalization", () => {
+                expect(categoryToTitle("github-actions")).toBe("GitHub Actions");
+            });
+
+            test("should format api-design with brand capitalization", () => {
+                expect(categoryToTitle("api-design")).toBe("API Design");
+            });
+
+            test("should format javascript-testing with brand capitalization", () => {
+                expect(categoryToTitle("javascript-testing")).toBe("JavaScript Testing");
+            });
+
+            test("should format test-coverage with standard title case", () => {
+                expect(categoryToTitle("test-coverage")).toBe("Test Coverage");
+            });
+
+            test("should format error-handling with standard title case", () => {
+                expect(categoryToTitle("error-handling")).toBe("Error Handling");
+            });
+
+            test("should format cross-platform with standard title case", () => {
+                expect(categoryToTitle("cross-platform")).toBe("Cross Platform");
+            });
+
+            test("should format ci-cd with brand names", () => {
+                expect(categoryToTitle("ci-cd")).toBe("CI CD");
+            });
+
+            test("should format typescript-nodejs with multiple brands", () => {
+                expect(categoryToTitle("typescript-nodejs")).toBe("TypeScript Node.js");
+            });
+        });
+
+        describe("complex multi-word categories", () => {
+            test("should format three-word category", () => {
+                expect(categoryToTitle("test-error-handling")).toBe("Test Error Handling");
+            });
+
+            test("should format category with multiple brands", () => {
+                expect(categoryToTitle("github-api-testing")).toBe("GitHub API Testing");
+            });
+
+            test("should format long category name", () => {
+                expect(categoryToTitle("comprehensive-test-coverage")).toBe(
+                    "Comprehensive Test Coverage"
+                );
+            });
+        });
+
+        describe("edge cases", () => {
+            test("should handle empty string", () => {
+                expect(categoryToTitle("")).toBe("");
+            });
+
+            test("should handle single character", () => {
+                expect(categoryToTitle("a")).toBe("A");
+            });
+
+            test("should handle category with numbers", () => {
+                expect(categoryToTitle("test123")).toBe("Test123");
+            });
+
+            test("should handle category starting with number", () => {
+                expect(categoryToTitle("3d-graphics")).toBe("3d Graphics");
+            });
+
+            test("should handle multiple consecutive hyphens as empty words", () => {
+                // Edge case: multiple hyphens create empty strings
+                const result = categoryToTitle("test--case");
+                expect(result).toBe("Test  Case");
+            });
+
+            test("should handle leading hyphen", () => {
+                const result = categoryToTitle("-testing");
+                expect(result).toBe(" Testing");
+            });
+
+            test("should handle trailing hyphen", () => {
+                const result = categoryToTitle("testing-");
+                expect(result).toBe("Testing ");
+            });
+
+            test("should handle already-capitalized input", () => {
+                expect(categoryToTitle("TESTING")).toBe("Testing");
+            });
+
+            test("should handle mixed-case input", () => {
+                expect(categoryToTitle("GitHub-Actions")).toBe("GitHub Actions");
+            });
+        });
+    });
+
+    describe("brand name coverage", () => {
+        test("should have all pure acronym brands in uppercase", () => {
+            // Only single-form acronyms (not plurals like APIs/URLs which keep lowercase 's')
+            const pureAcronymBrands = ["api", "cli", "json", "yaml", "xml", "html", "css", "sql", "url", "uri", "http", "https", "rest", "jwt", "sdk", "ide", "llm", "ai", "ml", "ci", "cd"];
+            for (const brand of pureAcronymBrands) {
+                const result = BRAND_NAMES[brand];
+                expect(result).toBeDefined();
+                expect(result).toBe(result.toUpperCase());
+            }
+        });
+
+        test("should have plural acronyms with lowercase s suffix", () => {
+            const pluralAcronyms = {
+                apis: "APIs",
+                urls: "URLs",
+                uris: "URIs",
+            };
+            for (const [input, expected] of Object.entries(pluralAcronyms)) {
+                expect(BRAND_NAMES[input]).toBe(expected);
+            }
+        });
+
+        test("should have proper camelCase brands", () => {
+            const camelCaseBrands = {
+                github: "GitHub",
+                javascript: "JavaScript",
+                typescript: "TypeScript",
+                graphql: "GraphQL",
+                webgl: "WebGL",
+                opengl: "OpenGL",
+                directx: "DirectX",
+            };
+            for (const [input, expected] of Object.entries(camelCaseBrands)) {
+                expect(BRAND_NAMES[input]).toBe(expected);
+            }
+        });
+
+        test("should have special case brands", () => {
+            const specialCases = {
+                npm: "npm", // all lowercase
+                macos: "macOS", // lowercase first letter
+                ios: "iOS", // lowercase first letter
+                nodejs: "Node.js", // with dot
+                csharp: "C#", // with symbol
+                dotnet: ".NET", // starts with dot
+                vscode: "VS Code", // with space
+                visualstudio: "Visual Studio", // with space
+                nuget: "NuGet", // mixed case
+                oauth: "OAuth", // mixed case
+            };
+            for (const [input, expected] of Object.entries(specialCases)) {
+                expect(BRAND_NAMES[input]).toBe(expected);
+            }
+        });
+    });
+
+    describe("integration scenarios", () => {
+        test("should format realistic category names correctly", () => {
+            const testCases = [
+                ["testing", "Testing"],
+                ["github-actions", "GitHub Actions"],
+                ["documentation", "Documentation"],
+                ["scripting", "Scripting"],
+                ["api", "API"],
+                ["javascript", "JavaScript"],
+                ["typescript", "TypeScript"],
+            ];
+            for (const [input, expected] of testCases) {
+                expect(categoryToTitle(input)).toBe(expected);
+            }
+        });
+
+        test("should handle all single-word brands as categories", () => {
+            for (const [slug, expected] of Object.entries(BRAND_NAMES)) {
+                expect(categoryToTitle(slug)).toBe(expected);
+            }
+        });
+    });
+});

package/scripts/__tests__/generate-skills-index.test.js.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 7fc490d5053dd9747a0f8aec3c839eb7
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: