@aini_ai_cody/icons 0.0.1 → 0.0.2

package/publish.sh

@@ -1,133 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-usage() {
-  cat <<'USAGE'
-Usage:
-  ./publish.sh [--dry-run] [--publish] [--tag <tag>] [--access <public|restricted>] [--registry <url>] [--otp <code>]
-
-Defaults:
-  --dry-run           Runs all checks and performs `npm publish --dry-run`.
-
-Options:
-  --publish           Actually publish to npm (dangerous). Without this flag, no real publish occurs.
-  --tag <tag>         npm dist-tag (default: latest)
-  --access <mode>     npm access (default: public for scoped packages)
-  --registry <url>    npm registry (optional)
-  --otp <code>        npm OTP (2FA), optional
-
-Environment:
-  NPM_TOKEN           If set, will be used for npm auth via a temporary npmrc (recommended for CI). Do NOT hardcode tokens in this script.
-USAGE
-}
-
-DRY_RUN=1
-TAG="latest"
-ACCESS="public"
-REGISTRY=""
-OTP=""
-
-while [[ $# -gt 0 ]]; do
-  case "$1" in
-    -h|--help)
-      usage
-      exit 0
-      ;;
-    --dry-run)
-      DRY_RUN=1
-      shift
-      ;;
-    --publish)
-      DRY_RUN=0
-      shift
-      ;;
-    --tag)
-      TAG="${2:-}"
-      shift 2
-      ;;
-    --access)
-      ACCESS="${2:-}"
-      shift 2
-      ;;
-    --registry)
-      REGISTRY="${2:-}"
-      shift 2
-      ;;
-    --otp)
-      OTP="${2:-}"
-      shift 2
-      ;;
-    *)
-      echo "Unknown argument: $1" >&2
-      usage
-      exit 2
-      ;;
-  esac
-done
-
-if [[ -z "$TAG" ]]; then
-  echo "--tag requires a value" >&2
-  exit 2
-fi
-
-if [[ "$ACCESS" != "public" && "$ACCESS" != "restricted" ]]; then
-  echo "--access must be 'public' or 'restricted'" >&2
-  exit 2
-fi
-
-if command -v git >/dev/null 2>&1; then
-  if [[ -n "$(git status --porcelain)" ]]; then
-    echo "Git working tree is not clean. Commit/stash changes before publishing." >&2
-    git status --porcelain >&2
-    exit 1
-  fi
-fi
-
-TMP_NPMRC=""
-cleanup() {
-  if [[ -n "${TMP_NPMRC}" && -f "${TMP_NPMRC}" ]]; then
-    rm -f "${TMP_NPMRC}"
-  fi
-}
-trap cleanup EXIT
-
-if [[ -n "${NPM_TOKEN:-}" ]]; then
-  TMP_NPMRC="$(mktemp -t cody-icons-npmrc.XXXXXX)"
-  {
-    echo "//registry.npmjs.org/:_authToken=${NPM_TOKEN}"
-    echo "always-auth=true"
-  } > "${TMP_NPMRC}"
-  export NPM_CONFIG_USERCONFIG="${TMP_NPMRC}"
-fi
-
-echo "Verifying npm auth..."
-if ! npm whoami >/dev/null 2>&1; then
-  echo "Not logged in to npm. Run 'npm login' or set NPM_TOKEN, then retry." >&2
-  exit 1
-fi
-
-echo "Running build..."
-pnpm run build
-
-echo "Running metadata checks..."
-pnpm run check-metadata
-
-PUBLISH_ARGS=("--tag" "$TAG" "--access" "$ACCESS")
-
-if [[ -n "$REGISTRY" ]]; then
-  PUBLISH_ARGS+=("--registry" "$REGISTRY")
-fi
-
-if [[ -n "$OTP" ]]; then
-  PUBLISH_ARGS+=("--otp" "$OTP")
-fi
-
-if [[ "$DRY_RUN" -eq 1 ]]; then
-  echo "Dry-run publish (no changes will be published)..."
-  npm publish --dry-run "${PUBLISH_ARGS[@]}"
-  echo "Done (dry-run)."
-else
-  echo "Publishing to npm..."
-  npm publish "${PUBLISH_ARGS[@]}"
-  echo "Done (published)."
-fi

package/scripts/check-metadata.js

@@ -1,149 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * This script checks which icons are missing metadata and reports them.
- * It helps maintain the metadata.json file by identifying gaps.
- */
-
-const fs = require('fs');
-const path = require('path');
-
-// Load the mapping file to get all icon names
-const mappingPath = path.join(__dirname, '..', 'src', 'template', 'mapping.json');
-const codyMappingPath = path.join(__dirname, '..', 'src', 'template', 'cody_mapping.json');
-const metadataPath = path.join(__dirname, '..', 'src', 'template', 'metadata.json');
-const codyMetadataPath = path.join(__dirname, '..', 'src', 'template', 'cody.json');
-
-if (!fs.existsSync(mappingPath)) {
-    console.error('Error: mapping.json not found at', mappingPath);
-    process.exit(1);
-}
-
-if (!fs.existsSync(metadataPath)) {
-    console.error('Error: metadata.json not found at', metadataPath);
-    process.exit(1);
-}
-
-const mapping = JSON.parse(fs.readFileSync(mappingPath, 'utf8'));
-const codyMapping = fs.existsSync(codyMappingPath)
-    ? JSON.parse(fs.readFileSync(codyMappingPath, 'utf8'))
-    : {};
-
-const metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
-const codyMetadata = fs.existsSync(codyMetadataPath)
-    ? JSON.parse(fs.readFileSync(codyMetadataPath, 'utf8'))
-    : {};
-
-const mergedMapping = { ...mapping, ...codyMapping };
-const mergedMetadata = { ...metadata, ...codyMetadata };
-
-// Collect all unique icon names from mapping
-const allIconNames = new Set();
-Object.values(mergedMapping).forEach(aliases => {
-    // For each code point, add the first alias (primary name)
-    if (aliases && aliases.length > 0) {
-        allIconNames.add(aliases[0]);
-    }
-});
-
-// Also include SVG-only Cody icons that are not part of the font mapping.
-// These live under src/cody_icons and are rendered via the Cody SVG sprite.
-const codyIconsDir = path.join(__dirname, '..', 'src', 'cody_icons');
-if (fs.existsSync(codyIconsDir)) {
-    fs.readdirSync(codyIconsDir)
-        .filter(name => name.toLowerCase().endsWith('.svg'))
-        .forEach(fileName => {
-            allIconNames.add(path.basename(fileName, '.svg'));
-        });
-}
-
-// Find icons without metadata
-const missingMetadata = [];
-allIconNames.forEach(iconName => {
-    if (!mergedMetadata[iconName]) {
-        missingMetadata.push(iconName);
-    }
-});
-
-// Find metadata for icons that don't exist
-const orphanedMetadata = [];
-Object.keys(mergedMetadata).forEach(iconName => {
-    if (!allIconNames.has(iconName)) {
-        orphanedMetadata.push(iconName);
-    }
-});
-
-// Report results
-console.log('='.repeat(60));
-console.log('Icon Metadata Coverage Report');
-console.log('='.repeat(60));
-console.log();
-
-console.log(`Total icons: ${allIconNames.size}`);
-console.log(`Icons with metadata: ${allIconNames.size - missingMetadata.length}`);
-console.log(`Coverage: ${Math.round(((allIconNames.size - missingMetadata.length) / allIconNames.size) * 100)}%`);
-console.log();
-
-if (missingMetadata.length > 0) {
-    console.log(`Icons missing metadata (${missingMetadata.length}):`);
-    console.log('-'.repeat(60));
-    missingMetadata.sort().forEach(name => {
-        console.log(`  - ${name}`);
-    });
-    console.log();
-}
-
-if (orphanedMetadata.length > 0) {
-    console.log(`Metadata entries for non-existent icons (${orphanedMetadata.length}):`);
-    console.log('-'.repeat(60));
-    orphanedMetadata.sort().forEach(name => {
-        console.log(`  - ${name}`);
-    });
-    console.log();
-}
-
-if (missingMetadata.length === 0 && orphanedMetadata.length === 0) {
-    console.log('✓ All icons have metadata and no orphaned entries found!');
-    console.log();
-}
-
-// Validate existing metadata structure
-const invalidEntries = [];
-Object.entries(mergedMetadata).forEach(([name, meta]) => {
-    const issues = [];
-
-    if (!meta.tags || !Array.isArray(meta.tags)) {
-        issues.push('missing or invalid tags array');
-    } else if (meta.tags.length === 0) {
-        issues.push('empty tags array');
-    }
-
-    if (!meta.category || typeof meta.category !== 'string') {
-        issues.push('missing or invalid category');
-    }
-
-    if (!meta.description || typeof meta.description !== 'string') {
-        issues.push('missing or invalid description');
-    }
-
-    if (issues.length > 0) {
-        invalidEntries.push({ name, issues });
-    }
-});
-
-if (invalidEntries.length > 0) {
-    console.log(`Metadata entries with validation issues (${invalidEntries.length}):`);
-    console.log('-'.repeat(60));
-    invalidEntries.forEach(({ name, issues }) => {
-        console.log(`  - ${name}:`);
-        issues.forEach(issue => {
-            console.log(`      * ${issue}`);
-        });
-    });
-    console.log();
-}
-
-// Exit with error if there are missing entries
-if (missingMetadata.length > 0 || orphanedMetadata.length > 0 || invalidEntries.length > 0) {
-    process.exit(1);
-}

package/scripts/embed-metadata.js

@@ -1,45 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-
-const metadataPath = path.join(__dirname, '../dist/metadata.json');
-const codySpritePath = path.join(__dirname, '../dist/cody-icons.svg');
-const htmlPath = path.join(__dirname, '../dist/codyicon.html');
-
-if (!fs.existsSync(htmlPath)) {
-    console.error('HTML file not found:', htmlPath);
-    process.exit(1);
-}
-
-const metadata = fs.readFileSync(metadataPath, 'utf8');
-const codySprite = fs.existsSync(codySpritePath)
-    ? fs
-        .readFileSync(codySpritePath, 'utf8')
-        .replace(/^\s*<\?xml[^>]*\?>\s*/i, '')
-        .replace(/^\s*<!doctype[^>]*>\s*/i, '')
-        .replace(/^\s*<svg[^>]*>/i, '')
-        .replace(/<\/svg>\s*$/i, '')
-    : '';
-let html = fs.readFileSync(htmlPath, 'utf8');
-
-const placeholder = '{} // METADATA_PLACEHOLDER';
-const replacement = `${metadata} // METADATA_PLACEHOLDER`;
-
-if (html.includes('// METADATA_PLACEHOLDER')) {
-    // Use regex to replace the initialization
-    html = html.replace(/let metadata = .* \/\/ METADATA_PLACEHOLDER/, `let metadata = ${metadata}; // METADATA_PLACEHOLDER`);
-
-    if (codySprite) {
-        const spriteContainerRegex = /<svg id="cody-svg-sprite"[^>]*>[\s\S]*?<\/svg>/;
-        if (spriteContainerRegex.test(html)) {
-            html = html.replace(
-                spriteContainerRegex,
-                `<svg id="cody-svg-sprite" aria-hidden="true" style="position:absolute;width:0;height:0;overflow:hidden">${codySprite}</svg>`
-            );
-        }
-    }
-
-    fs.writeFileSync(htmlPath, html);
-    console.log('Metadata embedded into HTML.');
-} else {
-    console.warn('Metadata placeholder not found in HTML.');
-}

package/scripts/export-to-csv.js

@@ -1,60 +0,0 @@
-// https://github.com/bitinn/character-map
-
-var opentype = require("opentype.js");
-
-const args = process.argv.slice(2);
-
-function getArgValue(flag) {
-  const index = args.indexOf(flag);
-  if (index === -1) return undefined;
-  const value = args[index + 1];
-  if (!value || value.startsWith("-")) return undefined;
-  return value;
-}
-
-const fontPath = getArgValue("-f");
-
-if (!fontPath || typeof fontPath !== "string") {
-  console.log(
-    "use -f to specify your font path, TrueType and OpenType supported"
-  );
-  return;
-}
-
-opentype.load(fontPath, function (err, font) {
-  if (err) {
-    console.log(err);
-    return;
-  }
-
-  var glyphs = font.glyphs.glyphs;
-  if (!glyphs || glyphs.length === 0) {
-    console.log("no glyphs found in this font");
-    return;
-  }
-
-  var table = "short_name,character,unicode";
-  for (glyphIndex in glyphs) {
-    var glyph = glyphs[glyphIndex];
-    var name = glyph.name;
-    var unicode = glyph.unicodes.map(formatUnicode).join(", ");
-    unicode = unicode.split(",")[0];
-    // var character = String.fromCharCode(glyph.unicode);
-    var character = String.fromCharCode(parseInt(glyph.unicodes.map(formatUnicode)[0], 16));
-    if (unicode) {
-      table += "\n" + name + "," + character + "," + unicode;
-    }
-
-  }
-
-  console.log(table);
-});
-
-function formatUnicode(unicode) {
-  unicode = unicode.toString(16);
-  if (unicode.length > 4) {
-    return ("000000" + unicode.toUpperCase()).substr(-6);
-  } else {
-    return ("0000" + unicode.toUpperCase()).substr(-4);
-  }
-}

package/scripts/export-to-ts.js

@@ -1,63 +0,0 @@
-const fs = require('fs');
-const args = process.argv.slice(2);
-
-function getArgValue(flag) {
-    const index = args.indexOf(flag);
-    if (index === -1) return undefined;
-    const value = args[index + 1];
-    if (!value || value.startsWith('-')) return undefined;
-    return value;
-}
-
-const mappingPath = getArgValue('-f');
-
-if (!mappingPath || typeof mappingPath !== "string") {
-    console.log("use -f to specify your mapping.json path");
-    return;
-}
-
-
-fs.readFile(mappingPath, 'utf8', (err, data) => {
-    if (err) {
-        console.error('Error reading file:', err);
-        return;
-    }
-
-    try {
-        const mapping = JSON.parse(data);
-
-        console.log("/*---------------------------------------------------------------------------------------------");
-        console.log(" *  Copyright (c) Cody. All rights reserved.");
-        console.log(" *  Licensed under the MIT License. See License.txt in the project root for license information.");
-        console.log(" *--------------------------------------------------------------------------------------------*/");
-        console.log("");
-        console.log("// This file is automatically generated by scripts/export-to-ts.js");
-        console.log("// Please don't edit it, as your changes will be overwritten.");
-        console.log("export const codyiconsLibrary = {");
-
-        // New format: mapping is { "code": ["alias1", "alias2", ...] }
-        Object.entries(mapping).forEach(([code, aliases]) => {
-            const codeValue = parseInt(code);
-            const hexValue = decimalToHex(codeValue);
-
-            // Register each alias with the same code
-            aliases.forEach((name) => {
-                console.log(`\t${toCamelCase(name)}: ${hexValue},`);
-            });
-        });
-
-        console.log("} as const;");
-
-    } catch (error) {
-        console.error('Error parsing JSON:', error);
-    }
-});
-
-
-function toCamelCase(name) {
-    return name.replace(/-([a-z])/g, function (g) { return g[1].toUpperCase(); });
-}
-
-function decimalToHex(decimal) {
-    return '0x' + decimal.toString(16);
-}

package/scripts/merge-cody.js

@@ -1,92 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-
-const root = path.resolve(__dirname, '..');
-const templateDir = path.join(root, 'src', 'template');
-const distDir = path.join(root, 'dist');
-
-const baseMappingPath = path.join(templateDir, 'mapping.json');
-const codyMappingPath = path.join(templateDir, 'cody_mapping.json');
-const baseMetadataPath = path.join(templateDir, 'metadata.json');
-const codyMetadataPath = path.join(templateDir, 'cody.json');
-
-function readJson(filePath, fallback) {
-    if (!fs.existsSync(filePath)) return fallback;
-    const raw = fs.readFileSync(filePath, 'utf8');
-    if (!raw.trim()) return fallback;
-    return JSON.parse(raw);
-}
-
-function ensureDir(dir) {
-    fs.mkdirSync(dir, { recursive: true });
-}
-
-function mergeMapping(baseMapping, codyMapping) {
-    const result = { ...baseMapping };
-
-    // Track aliases already in use to prevent accidental duplicates
-    const usedAliases = new Set();
-    for (const aliases of Object.values(baseMapping)) {
-        for (const name of aliases) usedAliases.add(name);
-    }
-
-    for (const [code, aliases] of Object.entries(codyMapping || {})) {
-        if (!Array.isArray(aliases) || aliases.length === 0) {
-            throw new Error(`Invalid cody_mapping.json entry for code ${code}: expected non-empty array`);
-        }
-
-        if (result[code]) {
-            throw new Error(`Codepoint collision at ${code}. Please choose a new numeric key in cody_mapping.json.`);
-        }
-
-        for (const name of aliases) {
-            if (typeof name !== 'string' || !name.trim()) {
-                throw new Error(`Invalid alias in cody_mapping.json at ${code}: expected non-empty string`);
-            }
-            if (usedAliases.has(name)) {
-                throw new Error(`Alias collision for '${name}'. It already exists in base mapping.json.`);
-            }
-        }
-
-        result[code] = aliases;
-        for (const name of aliases) usedAliases.add(name);
-    }
-
-    return result;
-}
-
-function mergeMetadata(baseMetadata, codyMetadata) {
-    const result = { ...baseMetadata };
-
-    for (const [name, meta] of Object.entries(codyMetadata || {})) {
-        if (result[name]) {
-            throw new Error(`Metadata key collision for '${name}'. It already exists in base metadata.json.`);
-        }
-        result[name] = meta;
-    }
-
-    return result;
-}
-
-function main() {
-    ensureDir(distDir);
-
-    const baseMapping = readJson(baseMappingPath, {});
-    const codyMapping = readJson(codyMappingPath, {});
-    const mergedMapping = mergeMapping(baseMapping, codyMapping);
-
-    const baseMetadata = readJson(baseMetadataPath, {});
-    const codyMetadata = readJson(codyMetadataPath, {});
-    const mergedMetadata = mergeMetadata(baseMetadata, codyMetadata);
-
-    fs.writeFileSync(path.join(distDir, 'mapping.json'), JSON.stringify(mergedMapping, null, 2) + '\n');
-    fs.writeFileSync(path.join(distDir, 'metadata.json'), JSON.stringify(mergedMetadata, null, 2) + '\n');
-
-    // List of Cody-specific icons (used for colored SVG sprite rendering)
-    const codyIconNames = Object.keys(codyMetadata || {}).sort();
-    fs.writeFileSync(path.join(distDir, 'cody-icons.json'), JSON.stringify(codyIconNames, null, 2) + '\n');
-
-    console.log('Merged mapping.json and metadata.json into dist/.');
-}
-
-main();

package/scripts/reset.js

@@ -1,10 +0,0 @@
-const fs = require("fs");
-
-const outputDirectory = "dist";
-
-// clear dist folder
-fs.rmSync(outputDirectory, { recursive: true, force: true });
-console.log(`deleted "${outputDirectory}" folder`);
-
-// re-create dist folder
-fs.mkdirSync(outputDirectory, { recursive: true });