@modkit-org/aksel-icons-vue 1.0.0

package/.changeset/config.json

@@ -0,0 +1,11 @@
+{
+	"$schema": "https://unpkg.com/@changesets/config@3.0.0/schema.json",
+	"changelog": "@changesets/cli/changelog",
+	"commit": false,
+	"fixed": [],
+	"linked": [],
+	"access": "public",
+	"baseBranch": "main",
+	"updateInternalDependencies": "patch",
+	"ignore": []
+}

package/.changeset/quick-insects-smash.md

@@ -0,0 +1,5 @@
+---
+"@modkit-org/aksel-icons-vue": patch
+---
+
+Initial release

package/.gitattributes

@@ -0,0 +1 @@
+* text=auto eol=lf

package/.github/scripts/check-latest-release.mjs

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+
+const DEFAULT_RELEASE_URL =
+  "https://api.github.com/repos/navikt/aksel/releases/latest";
+
+const args = parseArgs(process.argv.slice(2));
+const releaseUrl = args.releaseUrl ?? DEFAULT_RELEASE_URL;
+const plain = Boolean(args.plain);
+
+async function getAkselIconsVersion(url) {
+  if (!plain) {
+    console.log(`Fetching latest Aksel icons version from: ${url}`);
+  }
+
+  try {
+    const response = await fetch(url, {
+      headers: {
+        "User-Agent": "Node.js",
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status} ${response.statusText}`);
+    }
+
+    const payload = await response.json();
+    const version = payload?.tag_name;
+
+    if (!version) {
+      throw new Error("Response did not contain 'tag_name'.");
+    }
+
+    return version;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Failed to fetch version from GitHub: ${message}`);
+    process.exit(1);
+  }
+}
+
+function parseArgs(argv) {
+  const parsed = {};
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+
+    if (token === "--release-url" || token === "-r") {
+      const value = argv[index + 1];
+      if (value && !value.startsWith("-")) {
+        parsed.releaseUrl = value;
+        index += 1;
+      }
+      continue;
+    }
+
+    if (token.startsWith("--release-url=")) {
+      parsed.releaseUrl = token.slice("--release-url=".length);
+    }
+
+    if (token === "--plain" || token === "-p") {
+      parsed.plain = true;
+    }
+  }
+
+  return parsed;
+}
+
+const version = await getAkselIconsVersion(releaseUrl);
+if (!plain) {
+  console.log(`Aksel Icons Version: ${version}`);
+}
+console.log(version);

package/.github/workflows/publish.yml

@@ -0,0 +1,51 @@
+name: Release & Publish
+
+on:
+  push:
+    branches:
+      - main
+
+concurrency: ${{ github.workflow }}-${{ github.ref }}
+
+jobs:
+  release-and-publish:
+    name: Release & Publish
+    environment: npm
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+
+      - name: Setup Node
+        uses: actions/setup-node@v6
+        with:
+          node-version: 24
+          registry-url: "https://registry.npmjs.org"
+
+      - name: Cache Yarn
+        uses: actions/cache@v4
+        with:
+          path: |
+            .yarn/cache
+            .yarn/unplugged
+            .yarn/build-state.yml
+            .yarn/install-state.gz
+            .pnp.*
+          key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-yarn-
+
+      - name: Install Dependencies
+        run: yarn install
+
+      - name: Build packages
+        run: yarn build
+
+      - name: Create Release Pull Request or Publish
+        uses: changesets/action@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.REPOSITORY_PAT }}
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+        with:
+          version: yarn changeset version
+          publish: yarn changeset publish

package/.github/workflows/schedule-update-icons.yml

@@ -0,0 +1,58 @@
+name: Scheduled Icon Update
+
+on:
+  # schedule:
+  #   - cron: "0 5 1 * *"
+  workflow_dispatch:
+    inputs:
+      release_url:
+        description: "GitHub API URL for latest Aksel release"
+        required: false
+        default: "https://api.github.com/repos/navikt/aksel/releases/latest"
+
+concurrency: ${{ github.workflow }}-${{ github.ref }}
+
+jobs:
+  check-version:
+    name: Check Aksel version
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+
+    outputs:
+      should_dispatch: ${{ steps.compare.outputs.should_dispatch }}
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+      - name: Compare API version with metadata
+        id: compare
+        env:
+          RELEASE_URL: ${{ github.event.inputs.release_url || 'https://api.github.com/repos/navikt/aksel/releases/latest' }}
+        run: |
+          latest_version="$(node ./.github/scripts/check-latest-release.mjs --release-url "$RELEASE_URL" --plain)"
+          current_version="$(node -e "const fs=require('node:fs'); let current=''; try { const raw=fs.readFileSync('./src/metadata.json','utf8'); const parsed=JSON.parse(raw); current=parsed?.version ?? ''; } catch {} process.stdout.write(String(current));")"
+          should_dispatch="$(node -e "const current=process.argv[1] ?? ''; const latest=process.argv[2] ?? ''; process.stdout.write(String(current !== latest));" "$current_version" "$latest_version")"
+
+          {
+            echo "current_version=$current_version"
+            echo "latest_version=$latest_version"
+            echo "should_dispatch=$should_dispatch"
+          } >> "$GITHUB_OUTPUT"
+
+      - name: No update found
+        if: steps.compare.outputs.should_dispatch != 'true'
+        run: echo "No icon update available."
+
+  publish:
+    name: Call publish workflow
+    needs: check-version
+    if: needs.check-version.outputs.should_dispatch == 'true'
+    uses: ./.github/workflows/publish.yml
+    secrets: inherit

package/.yarnrc.yml

@@ -0,0 +1 @@
+nodeLinker: pnp

package/package.json

@@ -0,0 +1,30 @@
+{
+	"name": "@modkit-org/aksel-icons-vue",
+	"version": "1.0.0",
+	"description": "Aksel Icons Vue (unofficial)",
+	"packageManager": "yarn@4.12.0",
+	"type": "module",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/ModKit-Org/aksel-icons-vue.git"
+	},
+	"scripts": {
+		"check-latest-release": "node ./.github/scripts/check-latest-release.mjs",
+		"generate-icons": "node ./src/generate.mjs"
+	},
+	"dependencies": {
+		"extract-zip": "^2.0.1",
+		"yarn": "^1.22.22"
+	},
+	"keywords": [
+		"aksel",
+		"icons",
+		"vue",
+		"generator"
+	],
+	"author": "ModKit",
+	"license": "MIT",
+	"devDependencies": {
+		"@changesets/cli": "^2.29.8"
+	}
+}

package/src/generate.mjs

@@ -0,0 +1,103 @@
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { safeCleanup } from "./lib/cleanup.mjs";
+import { getGeneratorConfig, getHelpText } from "./lib/config.mjs";
+import { getIconDirectories } from "./lib/icon-package.mjs";
+import {
+  error as logError,
+  headline,
+  info,
+  setQuiet,
+  setVerbose,
+  success,
+  warn,
+} from "./lib/logger.mjs";
+import { readMetadata, writeMetadata } from "./lib/metadata.mjs";
+import { getGeneratorPaths } from "./lib/paths.mjs";
+import { collectSvgFilesByRoot } from "./lib/svg-discovery.mjs";
+import { generateVueFiles, writeIndexFile } from "./lib/vue-writer.mjs";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+let config;
+try {
+  config = getGeneratorConfig(process.argv.slice(2));
+} catch (err) {
+  const message = err instanceof Error ? err.message : String(err);
+  logError(message);
+  process.exit(1);
+}
+
+const { help, version, downloadUrl, tempDirectory, verbose, quiet } = config;
+
+if (help) {
+  console.log(getHelpText());
+  process.exit(0);
+}
+
+setQuiet(quiet);
+setVerbose(verbose && !quiet);
+
+const workspaceRoot = __dirname;
+const { metaFilePath, tempDirectoryAbsolute, typesRootPath } =
+  getGeneratorPaths(workspaceRoot, tempDirectory);
+
+main().catch(async (err) => {
+  const message = err instanceof Error ? err.message : String(err);
+  logError(`Generation failed: ${message}`);
+  await safeCleanup(tempDirectoryAbsolute);
+  process.exit(1);
+});
+
+async function main() {
+  headline("Aksel Icons Vue Generator");
+  if (verbose && !quiet) {
+    info("Verbose logging enabled.");
+  }
+
+  const existingMeta = await readMetadata(metaFilePath);
+
+  if (existingMeta?.version === version) {
+    success(
+      `Icons are already up to date (version: ${version}). No action needed.`,
+    );
+    process.exit(0);
+  }
+
+  if (existingMeta?.version) {
+    warn(`Updating icons from version ${existingMeta.version} to ${version}`);
+  } else {
+    info(
+      "No existing metadata.json found. Generating icons for the first time.",
+    );
+  }
+
+  info("Starting icon generation process...");
+  await mkdir(tempDirectoryAbsolute, { recursive: true });
+
+  info(`Latest icon version: ${version}`);
+  const extractedDirectories = await getIconDirectories(
+    downloadUrl,
+    tempDirectoryAbsolute,
+  );
+
+  const groupedSvgFiles = await collectSvgFilesByRoot(extractedDirectories);
+  const exports = await generateVueFiles({
+    groupedSvgFiles,
+    typesRootPath,
+    version,
+    downloadUrl,
+  });
+
+  await writeIndexFile(typesRootPath, exports, version, downloadUrl);
+  success("Done writing index.ts");
+
+  await writeMetadata(metaFilePath, version);
+  success("Done writing metadata.json");
+
+  await safeCleanup(tempDirectoryAbsolute, true);
+  success("Generation completed successfully.");
+  process.exit(0);
+}

package/src/lib/cleanup.mjs

@@ -0,0 +1,18 @@
+import { rm } from "node:fs/promises";
+import { pathExists } from "./fs-utils.mjs";
+import { step } from "./logger.mjs";
+
+export async function safeCleanup(directoryPath, printMessage = false) {
+  try {
+    const exists = await pathExists(directoryPath);
+    if (exists && printMessage) {
+      step("Cleaning up temporary files...");
+    }
+
+    if (exists) {
+      await rm(directoryPath, { recursive: true, force: true });
+    }
+  } catch {
+    // Ignore cleanup errors to preserve original script behavior.
+  }
+}

package/src/lib/config.mjs

@@ -0,0 +1,105 @@
+export const DEFAULT_DOWNLOAD_URL =
+  "https://cdn.nav.no/aksel/icons/zip/aksel-icons.zip";
+
+export function getHelpText() {
+  return [
+    "Aksel Icons Vue Generator",
+    "",
+    "Usage:",
+    "  yarn generate-icons --version <value> [options]",
+    "",
+    "Required:",
+    "  --version, -v <value>      Version to store in metadata and generated headers",
+    "",
+    "Options:",
+    `  --download-url, -d <url>   Icon zip URL (default: ${DEFAULT_DOWNLOAD_URL})`,
+    "  --temp-directory, -t <path> Temporary working directory (default: ./temp-icons)",
+    "  --verbose                  Show detailed per-directory progress",
+    "  --quiet, -q                Show warnings/errors only",
+    "  --help, -h                 Show this help",
+  ].join("\n");
+}
+
+export function parseArgs(argv) {
+  const parsed = {};
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token.startsWith("-")) {
+      continue;
+    }
+
+    const normalized = token.replace(/^-+/, "");
+    const next = argv[index + 1];
+    if (!next || next.startsWith("-")) {
+      parsed[normalized] = "true";
+      continue;
+    }
+
+    parsed[normalized] = next;
+    index += 1;
+  }
+
+  return parsed;
+}
+
+export function getGeneratorConfig(argv) {
+  const args = parseArgs(argv);
+
+  const help = parseBooleanFlag(args.help ?? args.h ?? false);
+
+  if (help) {
+    return {
+      help: true,
+      version: "",
+      downloadUrl: DEFAULT_DOWNLOAD_URL,
+      tempDirectory: "./temp-icons",
+      verbose: false,
+      quiet: false,
+    };
+  }
+
+  const version = args.version ?? args.v ?? "";
+  const downloadUrl = args["download-url"] ?? args.d ?? DEFAULT_DOWNLOAD_URL;
+  const tempDirectory = args["temp-directory"] ?? args.t ?? "./temp-icons";
+  const verbose = parseBooleanFlag(args.verbose ?? false);
+  const quiet = parseBooleanFlag(args.quiet ?? args.q ?? false);
+
+  if (!version || version === "true") {
+    throw new Error("'version' parameter is required.");
+  }
+
+  if (!downloadUrl) {
+    throw new Error("'downloadUrl' parameter is required.");
+  }
+
+  return {
+    help: false,
+    version,
+    downloadUrl,
+    tempDirectory,
+    verbose,
+    quiet,
+  };
+}
+
+function parseBooleanFlag(value) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+
+  const normalized = String(value).trim().toLowerCase();
+  if (!normalized) {
+    return false;
+  }
+
+  if (["1", "true", "yes", "on"].includes(normalized)) {
+    return true;
+  }
+
+  if (["0", "false", "no", "off"].includes(normalized)) {
+    return false;
+  }
+
+  return true;
+}

package/src/lib/fs-utils.mjs

@@ -0,0 +1,10 @@
+import { stat } from "node:fs/promises";
+
+export async function pathExists(targetPath) {
+  try {
+    await stat(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/lib/icon-package.mjs

@@ -0,0 +1,59 @@
+import extract from "extract-zip";
+import { createWriteStream } from "node:fs";
+import { readdir } from "node:fs/promises";
+import path from "node:path";
+import { pipeline } from "node:stream/promises";
+import { info, step } from "./logger.mjs";
+
+export async function getIconDirectories(url, destinationPath) {
+  const zipFilePath = path.join(destinationPath, "icons.zip");
+
+  info(`Downloading icon package from: ${url}`);
+  const response = await fetch(url);
+  if (!response.ok || !response.body) {
+    throw new Error(
+      `Failed to download icons from ${url}. HTTP ${response.status}`,
+    );
+  }
+
+  await pipeline(response.body, createWriteStream(zipFilePath));
+
+  step("Extracting icon package...");
+  await extract(zipFilePath, { dir: destinationPath });
+
+  const candidates = await readdir(destinationPath, { withFileTypes: true });
+  const extractedDirectories = [];
+  for (const candidate of candidates) {
+    if (!candidate.isDirectory()) {
+      continue;
+    }
+
+    const directoryPath = path.join(destinationPath, candidate.name);
+    if (await directoryContainsSvg(directoryPath)) {
+      extractedDirectories.push(directoryPath);
+    }
+  }
+
+  if (extractedDirectories.length === 0) {
+    throw new Error("Could not find extracted Icon directories");
+  }
+
+  return extractedDirectories;
+}
+
+async function directoryContainsSvg(directoryPath) {
+  const entries = await readdir(directoryPath, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(directoryPath, entry.name);
+    if (entry.isFile() && entry.name.toLowerCase().endsWith(".svg")) {
+      return true;
+    }
+
+    if (entry.isDirectory() && (await directoryContainsSvg(fullPath))) {
+      return true;
+    }
+  }
+
+  return false;
+}

package/src/lib/identifier.mjs

@@ -0,0 +1,23 @@
+export function convertToValidIdentifier(label) {
+  let result = "";
+  let capitalize = true;
+
+  for (const char of label) {
+    if (/^[a-zA-Z0-9]$/.test(char)) {
+      if (capitalize) {
+        result += char.toUpperCase();
+        capitalize = false;
+      } else {
+        result += char;
+      }
+    } else {
+      capitalize = true;
+    }
+  }
+
+  if (/^\d/.test(result)) {
+    return `Number${result}`;
+  }
+
+  return result;
+}

package/src/lib/logger.mjs

@@ -0,0 +1,77 @@
+const supportsColor = process.stdout.isTTY && !process.env.NO_COLOR;
+let verboseEnabled = false;
+let quietEnabled = false;
+
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const RED = "\x1b[31m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const BLUE = "\x1b[34m";
+const MAGENTA = "\x1b[35m";
+const CYAN = "\x1b[36m";
+
+function paint(text, ...codes) {
+  if (!supportsColor) {
+    return text;
+  }
+
+  return `${codes.join("")}${text}${RESET}`;
+}
+
+export function setVerbose(enabled) {
+  verboseEnabled = Boolean(enabled);
+}
+
+export function setQuiet(enabled) {
+  quietEnabled = Boolean(enabled);
+}
+
+export function headline(text) {
+  if (quietEnabled) {
+    return;
+  }
+
+  console.log(`\n${paint(`◆ ${text}`, BOLD, MAGENTA)}`);
+}
+
+export function section(text) {
+  if (quietEnabled || !verboseEnabled) {
+    return;
+  }
+
+  console.log(`\n${paint(`▶ ${text}`, BOLD, CYAN)}`);
+}
+
+export function info(text) {
+  if (quietEnabled) {
+    return;
+  }
+
+  console.log(paint(`ℹ ${text}`, BLUE));
+}
+
+export function step(text) {
+  if (quietEnabled || !verboseEnabled) {
+    return;
+  }
+
+  console.log(paint(`• ${text}`, DIM));
+}
+
+export function success(text) {
+  if (quietEnabled) {
+    return;
+  }
+
+  console.log(paint(`✔ ${text}`, GREEN));
+}
+
+export function warn(text) {
+  console.log(paint(`⚠ ${text}`, YELLOW));
+}
+
+export function error(text) {
+  console.error(paint(`✖ ${text}`, RED));
+}

package/src/lib/metadata.mjs

@@ -0,0 +1,25 @@
+import { access, constants, readFile, writeFile } from "node:fs/promises";
+
+export async function readMetadata(metaPath) {
+  try {
+    await access(metaPath, constants.F_OK);
+  } catch {
+    return null;
+  }
+
+  try {
+    const json = await readFile(metaPath, "utf8");
+    return JSON.parse(json);
+  } catch {
+    return null;
+  }
+}
+
+export async function writeMetadata(metaPath, version) {
+  const payload = {
+    version,
+    generatedAt: new Date().toISOString().replace(/\.\d{3}Z$/, "Z"),
+  };
+
+  await writeFile(metaPath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+}

package/src/lib/path-utils.mjs

@@ -0,0 +1,3 @@
+export function normalizePath(value) {
+  return value.replaceAll("\\", "/");
+}

package/src/lib/paths.mjs

@@ -0,0 +1,10 @@
+import path from "node:path";
+
+export function getGeneratorPaths(workspaceRoot, tempDirectory) {
+  return {
+    workspaceRoot,
+    metaFilePath: path.join(workspaceRoot, "metadata.json"),
+    tempDirectoryAbsolute: path.resolve(workspaceRoot, tempDirectory),
+    typesRootPath: path.join(workspaceRoot, "types"),
+  };
+}