@flow-scanner/lightning-flow-scanner-core 6.17.1 → 6.17.2

package/eslint.config.mjs

@@ -1,36 +0,0 @@
-import deMorgan from "eslint-plugin-de-morgan";
-import github from "eslint-plugin-github";
-import pluginJest from "eslint-plugin-jest";
-import perfectionist from "eslint-plugin-perfectionist";
-import sonarjs from "eslint-plugin-sonarjs";
-import globals from "globals";
-import tseslint from "typescript-eslint";
-
-export default [
-  { languageOptions: { globals: globals.browser } },
-  ...tseslint.configs.recommended,
-  {
-    files: ["tests/*.test.ts"],
-    languageOptions: {
-      globals: pluginJest.environments.globals.globals,
-    },
-    plugins: { jest: pluginJest },
-    rules: {
-      "jest/no-alias-methods": "error",
-      "jest/no-disabled-tests": "warn",
-      "jest/no-focused-tests": "error",
-      "jest/no-identical-title": "error",
-      "jest/prefer-to-have-length": "warn",
-      "jest/valid-expect": "error",
-    },
-  },
-  {
-    ignores: ["jest.config.ts", "example-flows/**"],
-  },
-  perfectionist.configs["recommended-alphabetical"],
-  perfectionist.configs["recommended-line-length"],
-  perfectionist.configs["recommended-natural"],
-  sonarjs.configs.recommended,
-  deMorgan.configs.recommended,
-  ...github.getFlatConfigs().typescript,
-];

package/jest.config.cjs

@@ -1,32 +0,0 @@
-module.exports = {
-  automock: false,
-  clearMocks: true,
-  collectCoverage: true,
-  coverageDirectory: "coverage",
-  coverageProvider: "v8",
-  coverageReporters: ["json", "text", "lcov"],
-  modulePathIgnorePatterns: ["./jest.config.cjs", "./out/"],
-  setupFilesAfterEnv: ["<rootDir>/jest.env-setup.js"],
-  testEnvironment: "node",
-  testPathIgnorePatterns: ["/node_modules/"],
-  transform: {
-    "^.+\\.(t|j)sx?$": [
-      "@swc-node/jest",
-      {
-        module: "commonjs",
-        swc: {
-          jsc: {
-            target: "es2020",
-            parser: {
-              syntax: "typescript",
-              tsx: false,
-            },
-          },
-          sourceMaps: "inline",
-          minify: false,
-        },
-      },
-    ],
-  },
-  transformIgnorePatterns: ["/node_modules/", "\\.pnp\\.[^\\/]+$"],
-};

package/jest.env-setup.js

@@ -1,101 +0,0 @@
-const fs = require("fs");
-const path = require("path");
-
-module.exports = () => {
-  if (!process.env.UMD_PATH) {
-    console.log("UMD Setup: No UMD_PATH—skipping (Node-only mode)");
-    return;
-  }
-
-  const umdFilePath = path.resolve(process.env.UMD_PATH);
-
-  if (!fs.existsSync(umdFilePath)) {
-    console.warn("UMD Setup: File not found at", umdFilePath, "—skipping.");
-    return;
-  }
-
-  let umdCode = fs.readFileSync(umdFilePath, "utf8");
-  const fastXmlParser = require("fast-xml-parser");
-
-  // Vite UMD pattern: (function(global, factory) { ... })(this, function(exports, dependency) { ... });
-  // We need to extract and execute the factory function
-
-  // Try to match Vite's UMD pattern more flexibly
-  const viteUmdMatch = umdCode.match(
-    /\(function\s*\([^,]+,\s*(\w+)\)\s*\{[\s\S]*?\}\)\s*\(this,\s*function\s*\((\w+)(?:,\s*(\w+))?\)\s*\{([\s\S]+)\}\s*\)\s*;?\s*$/
-  );
-
-  if (viteUmdMatch) {
-    const factoryBody = viteUmdMatch[4];
-    const exportsParam = viteUmdMatch[2];
-    const depParam = viteUmdMatch[3];
-
-    try {
-      // Create the factory function with proper parameters
-      const factoryFn = depParam
-        ? new Function(exportsParam, depParam, factoryBody)
-        : new Function(exportsParam, factoryBody);
-
-      // Create exports object and invoke factory
-      const exports = {};
-      if (depParam) {
-        factoryFn(exports, fastXmlParser);
-      } else {
-        factoryFn(exports);
-      }
-
-      // Assign to global
-      global.lightningflowscanner = exports;
-
-      if (Object.keys(exports).length === 0) {
-        console.error("UMD Setup: WARNING - exports object is empty!");
-      }
-    } catch (e) {
-      console.error("UMD Factory error:", e.message);
-      console.error("Stack:", e.stack);
-    }
-  } else {
-    // Fallback: Try direct execution approach
-
-    try {
-      // Create a mock global/window context
-      const mockGlobal = {};
-      const mockFactory = new Function(
-        "global",
-        "factory",
-        `
-        return (function(root, factoryFn) {
-          if (typeof exports === 'object' && typeof module !== 'undefined') {
-            factoryFn(exports, require('fast-xml-parser'));
-          } else {
-            factoryFn((root.lightningflowscanner = {}), root.fastXmlParser);
-          }
-        })(global, factory);
-      `
-      );
-
-      // Execute in controlled context
-      const vm = require("vm");
-      const sandbox = {
-        exports: {},
-        require: (id) => (id === "fast-xml-parser" ? fastXmlParser : require(id)),
-        module: { exports: {} },
-        console: console,
-      };
-
-      vm.runInNewContext(umdCode, sandbox);
-
-      // Check what got exported
-      const exports = sandbox.exports.default || sandbox.exports || sandbox.module.exports;
-
-      if (exports && Object.keys(exports).length > 0) {
-        global.lightningflowscanner = exports;
-      } else {
-        console.error("UMD Setup: Direct execution failed - no exports found");
-      }
-    } catch (e) {
-      console.error("UMD Direct execution error:", e.message);
-      console.error("Stack:", e.stack.slice(0, 400));
-    }
-  }
-};

package/lint-staged.config.mjs

@@ -1,8 +0,0 @@
-import micromatch from "micromatch";
-
-const isNotExampleFlows = (files) => micromatch.not(files, ["example-flows/**"]);
-
-export default {
-  "**/*.{js,json,md,xml,yaml,yml}": (files) =>
-    isNotExampleFlows(files).map((f) => `prettier --write "${f}"`),
-};

package/prettier.config.mjs

@@ -1,5 +0,0 @@
-export default {
-  printWidth: 100,
-  tabWidth: 2,
-  trailingComma: "es5",
-};

package/src/index.ts

@@ -1,52 +0,0 @@
-// Updated exports in index.ts
-import type { IRuleDefinition } from "./main/interfaces/IRuleDefinition";
-import type { IRulesConfig } from "./main/interfaces/IRulesConfig";
-import type { FlatViolation } from "./main/models/FlatViolation";
-import { Compiler } from "./main/libs/Compiler";
-import { exportDetails } from "./main/libs/ExportDetails";
-import { exportSarif } from "./main/libs/ExportSarif";
-import { fix } from "./main/libs/FixFlows";
-import { getRules } from "./main/libs/GetRuleDefinitions";
-import { parse } from "./main/libs/ParseFlows";
-import { scan } from "./main/libs/ScanFlows";
-import { Flow } from "./main/models/Flow";
-import { FlowAttribute } from "./main/models/FlowAttribute";
-import { FlowElement } from "./main/models/FlowElement";
-import { FlowNode } from "./main/models/FlowNode";
-import { FlowResource } from "./main/models/FlowResource";
-import { FlowType } from "./main/models/FlowType";
-import { FlowVariable } from "./main/models/FlowVariable";
-import { ParsedFlow } from "./main/models/ParsedFlow";
-import { RuleResult } from "./main/models/RuleResult";
-import { ScanResult } from "./main/models/ScanResult";
-import { Violation } from "./main/models/Violation";
-import { DEFAULT_ICONS, ASCII_ICONS, type NodeIconConfig } from "./main/config/NodeIcons";
-import { DEFAULT_VARIABLE_ICONS, ASCII_VARIABLE_ICONS, type VariableIconConfig } from "./main/config/VariableIcons";
-import { exportDiagram, type DiagramOptions } from "./main/libs/ExportDiagram";
-
-export {
-  Compiler,
-  exportDetails,
-  exportDiagram,
-  exportSarif,
-  fix,
-  Flow,
-  FlowAttribute,
-  FlowElement,
-  FlowNode,
-  FlowResource,
-  FlowType,
-  FlowVariable,
-  getRules,
-  parse,
-  ParsedFlow,
-  Violation,
-  RuleResult,
-  scan,
-  ScanResult,
-  DEFAULT_ICONS,
-  ASCII_ICONS,
-  DEFAULT_VARIABLE_ICONS,
-  ASCII_VARIABLE_ICONS,
-};
-export type { FlatViolation, IRuleDefinition, IRulesConfig, NodeIconConfig, DiagramOptions, VariableIconConfig };

package/src/main/config/NodeIcons.ts

@@ -1,98 +0,0 @@
-/**
- * Icon configuration for flow node types.
- * Emoji are safe in UTF-8 encoded source files and will work in all modern builds.
- * If you need ASCII fallback, use FlowNode.setIconConfig(ASCII_ICONS)
- */
-
-export interface NodeIconConfig {
-  [nodeType: string]: {
-    [subtype: string]: string;
-  } | { default: string };
-}
-
-/**
- * Default icons using emoji (recommended for modern environments)
- */
-export const DEFAULT_ICONS: NodeIconConfig = {
-  actionCalls: {
-    apex: '\u2699\uFE0F',           // GEAR (with emoji presentation)
-    emailAlert: '\uD83D\uDCE7',     // E-MAIL
-    emailSimple: '\uD83D\uDCE7',    // E-MAIL
-    submit: '\u26A1',               // HIGH VOLTAGE
-    default: '\u26A1'               // HIGH VOLTAGE
-  },
-  assignments: { 
-    default: '\uD83D\uDFF0'         // 🟰 HEAVY EQUALS SIGN
-  },
-  collectionProcessors: {
-    FilterCollectionProcessor: '\uD83D\uDD3D',  // DOWN BUTTON
-    SortCollectionProcessor: '\uD83D\uDD03',    // CLOCKWISE ARROWS
-    default: '\uD83D\uDCE6'         // PACKAGE
-  },
-  customErrors: { 
-    default: '\uD83D\uDEAB'         // PROHIBITED
-  },
-  decisions: { 
-    default: '\uD83D\uDD00'         // TWISTED ARROWS
-  },
-  loops: { 
-    default: '\uD83D\uDD01'         // REPEAT BUTTON
-  },
-  recordCreates: { 
-    default: '\u2795'               // PLUS
-  },
-  recordDeletes: { 
-    default: '\uD83D\uDDD1\uFE0F'   // WASTEBASKET
-  },
-  recordLookups: { 
-    default: '\uD83D\uDD0D'         // MAGNIFYING GLASS
-  },
-  recordUpdates: { 
-    default: '\uD83D\uDEE0\uFE0F'   // HAMMER AND WRENCH
-  },
-  screens: { 
-    default: '\uD83D\uDCBB'         // LAPTOP
-  },
-  subflows: { 
-    default: '\uD83D\uDD17'         // LINK
-  },
-  transforms: { 
-    default: '\u267B\uFE0F'
-  },
-};
-
-/**
- * ASCII fallback icons (for environments without emoji support)
- */
-export const ASCII_ICONS: NodeIconConfig = {
-  actionCalls: {
-    apex: '[A]',
-    emailAlert: '[E]',
-    emailSimple: '[E]',
-    submit: '[!]',
-    default: '[!]'
-  },
-  assignments: { default: '[=]' },
-  collectionProcessors: {
-    FilterCollectionProcessor: '[F]',
-    SortCollectionProcessor: '[S]',
-    default: '[C]'
-  },
-  customErrors: { default: '[X]' },
-  decisions: { default: '[?]' },
-  loops: { default: '[L]' },
-  recordCreates: { default: '[+]' },
-  recordDeletes: { default: '[-]' },
-  recordLookups: { default: '[S]' },
-  recordUpdates: { default: '[U]' },
-  screens: { default: '[#]' },
-  subflows: { default: '[>]' },
-  transforms: { default: '[T]' },
-};
-
-/**
- * Get default icon config (can be overridden at runtime)
- */
-export function getDefaultIconConfig(): NodeIconConfig {
-  return DEFAULT_ICONS;
-}

package/src/main/config/RegexAdapter.ts

@@ -1,98 +0,0 @@
-/**
- * Adapter functions to convert between core models (Flow, Violation)
- * and regex-scanner models (MetadataFile, RegexViolation).
- *
- * This allows core rules to delegate to regex-scanner while maintaining
- * backward compatibility with existing consumers.
- */
-
-import type {
-  MetadataFile,
-  MetadataElement,
-  RegexViolation,
-} from "@flow-scanner/regex-scanner";
-
-import { Flow } from "../models/Flow";
-import { FlowAttribute } from "../models/FlowAttribute";
-import { FlowElement } from "../models/FlowElement";
-import { Violation } from "../models/Violation";
-import { MetaType } from "../enums/MetadataTypes";
-
-/**
- * Convert a Flow object to a MetadataFile for regex-scanner.
- */
-export function toMetadataFile(flow: Flow): MetadataFile {
-  // Handle case where toXMLString may not exist (e.g., in tests with partial Flow objects)
-  let content = "";
-  if (typeof flow.toXMLString === "function") {
-    content = flow.toXMLString();
-  }
-
-  return {
-    name: flow.name,
-    fileName: flow.uri
-      ? flow.uri.split(/[\\/]/).pop() ?? `${flow.name}.flow-meta.xml`
-      : `${flow.name}.flow-meta.xml`,
-    filePath: flow.fsPath,
-    metadataType: "Flow",
-    content,
-    elements: toMetadataElements(flow),
-  };
-}
-
-/**
- * Convert Flow elements to MetadataElements for element-level scanning.
- */
-export function toMetadataElements(flow: Flow): MetadataElement[] {
-  if (!flow.elements || flow.elements.length === 0) {
-    return [];
-  }
-
-  return flow.elements.map((element) => ({
-    name: element.name,
-    type: element.subtype,
-    content: element.element ?? element,
-  }));
-}
-
-/**
- * Convert a RegexViolation to a core Violation.
- * Creates the appropriate FlowElement subclass based on metaType.
- */
-export function toViolation(rv: RegexViolation): Violation {
-  // Create a FlowAttribute to represent the violation
-  // This is the simplest approach that works for all regex rules
-  const flowElement = new FlowAttribute(
-    rv.name,
-    rv.type,
-    rv.expression ?? rv.matchedText
-  );
-
-  const violation = new Violation(flowElement);
-
-  // Override line/column from regex violation
-  violation.lineNumber = rv.lineNumber;
-  violation.columnNumber = rv.columnNumber;
-
-  return violation;
-}
-
-/**
- * Convert a core FlowElement to a regex-scanner MetadataElement.
- */
-export function flowElementToMetadataElement(
-  element: FlowElement
-): MetadataElement {
-  return {
-    name: element.name,
-    type: element.subtype,
-    content: element.element ?? element,
-  };
-}
-
-/**
- * Convert multiple RegexViolations to core Violations.
- */
-export function toViolations(violations: RegexViolation[]): Violation[] {
-  return violations.map(toViolation);
-}

package/src/main/config/RuleRegistry.ts

@@ -1,188 +0,0 @@
-import { IRuleDefinition } from "../interfaces/IRuleDefinition";
-import { IRuleConfig } from "../interfaces/IRuleConfig";
-import { IRulesConfig } from "../interfaces/IRulesConfig";
-// Import all rules
-import { ActionCallsInLoop } from "../rules/ActionCallsInLoop";
-import { APIVersion } from "../rules/APIVersion";
-import { AutoLayout } from "../rules/AutoLayout";
-import { CopyAPIName } from "../rules/CopyAPIName";
-import { CyclomaticComplexity } from "../rules/CyclomaticComplexity";
-import { DMLStatementInLoop } from "../rules/DMLStatementInLoop";
-import { DuplicateDMLOperation } from "../rules/DuplicateDMLOperation";
-import { FlowDescription } from "../rules/FlowDescription";
-import { FlowName } from "../rules/FlowName";
-import { GetRecordAllFields } from "../rules/GetRecordAllFields";
-import { HardcodedId } from "../rules/HardcodedId";
-import { HardcodedUrl } from "../rules/HardcodedUrl";
-import { HardcodedSecret } from "../rules/HardcodedSecret";
-import { InactiveFlow } from "../rules/InactiveFlow";
-import { MissingFaultPath } from "../rules/MissingFaultPath";
-import { MissingNullHandler } from "../rules/MissingNullHandler";
-import { ProcessBuilder } from "../rules/ProcessBuilder";
-import { RecursiveAfterUpdate } from "../rules/RecursiveAfterUpdate";
-import { SameRecordFieldUpdates } from "../rules/SameRecordFieldUpdates";
-import { SOQLQueryInLoop } from "../rules/SOQLQueryInLoop";
-import { TriggerOrder } from "../rules/TriggerOrder";
-import { UnconnectedElement } from "../rules/UnconnectedElement";
-import { UnsafeRunningContext } from "../rules/UnsafeRunningContext";
-import { UnusedVariable } from "../rules/UnusedVariable";
-import { MissingMetadataDescription } from "../rules/MissingMetadataDescription";
-import { MissingRecordTriggerFilter } from "../rules/MissingRecordTriggerFilter";
-import { TransformInsteadOfLoop } from "../rules/TransformInsteadOfLoop";
-import { RecordIdAsString } from "../rules/RecordIdAsString";
-
-type RuleConstructor = new () => IRuleDefinition;
-
-interface RuleRegistryEntry {
-  ruleId: string;
-  ruleClass: RuleConstructor;
-  legacyName: string;
-  isBeta: boolean;
-}
-
-class RuleRegistry {
-  private rules: Map<string, RuleRegistryEntry> = new Map();
-  private legacyNameMap: Map<string, string> = new Map();
-
-  register(
-    ruleId: string,
-    ruleClass: RuleConstructor,
-    legacyName: string,
-    isBeta: boolean = false
-  ): void {
-    const entry: RuleRegistryEntry = {
-      ruleId,
-      ruleClass,
-      legacyName,
-      isBeta,
-    };
-    this.rules.set(ruleId, entry);
-    this.legacyNameMap.set(legacyName, ruleId);
-  }
-
-  get(idOrLegacyName: string): RuleRegistryEntry | undefined {
-    let entry = this.rules.get(idOrLegacyName);
-    if (!entry) {
-      const ruleId = this.legacyNameMap.get(idOrLegacyName);
-      if (ruleId) {
-        entry = this.rules.get(ruleId);
-      }
-    }
-    return entry;
-  }
-
-  getAllRuleIds(includeBeta: boolean = false): string[] {
-    return Array.from(this.rules.values())
-      .filter(entry => includeBeta || !entry.isBeta)
-      .map(entry => entry.ruleId);
-  }
-
-  has(idOrLegacyName: string): boolean {
-    return this.get(idOrLegacyName) !== undefined;
-  }
-
-  createInstance(idOrLegacyName: string): IRuleDefinition {
-    const entry = this.get(idOrLegacyName);
-    if (!entry) {
-      throw new Error(`Rule not found: ${idOrLegacyName}`);
-    }
-    return new entry.ruleClass();
-  }
-
-  getRules(
-    ruleConfig?: Map<string, unknown>,
-    options?: IRulesConfig
-  ): IRuleDefinition[] {
-    const includeBeta = options?.betaMode === true || options?.betamode === true;
-    const rulesMode = options?.ruleMode || "merged";
-    const selectedRules: IRuleDefinition[] = [];
-
-    if (rulesMode === "isolated" && ruleConfig && ruleConfig.size > 0) {
-      for (const key of ruleConfig.keys()) {
-        const entry = this.get(key);
-        if (!entry) continue;
-
-        const config = ruleConfig.get(key) as IRuleConfig | undefined;
-        if (config?.enabled === false) continue;
-
-        const rule = this.createInstance(entry.ruleId);
-        if (config?.severity) {
-          rule.severity = config.severity;
-        }
-
-        selectedRules.push(rule);
-      }
-      return selectedRules;
-    }
-
-    const allRuleIds = this.getAllRuleIds(includeBeta);
-
-    for (const ruleId of allRuleIds) {
-      const rule = this.createInstance(ruleId);
-
-      const config = (
-        ruleConfig?.get(rule.ruleId) ??
-        ruleConfig?.get(rule.name)
-      ) as IRuleConfig | undefined;
-
-      if (config?.enabled === false) continue;
-      if (config?.severity) {
-        rule.severity = config.severity;
-      }
-
-      selectedRules.push(rule);
-    }
-
-    return selectedRules;
-  }
-
-  getRulesByNames(ruleNames?: string[], options?: IRulesConfig): IRuleDefinition[] {
-    if (!ruleNames || ruleNames.length === 0) {
-      return this.getRules(undefined, options);
-    }
-
-    const config = new Map<string, IRuleConfig>();
-    for (const identifier of ruleNames) {
-      const entry = this.get(identifier);
-      if (entry) {
-        config.set(entry.ruleId, { enabled: true });
-      }
-    }
-
-    return this.getRules(config, { ...options, ruleMode: "isolated" });
-  }
-}
-
-const registry = new RuleRegistry();
-
-registry.register("action-call-in-loop", ActionCallsInLoop, "ActionCallsInLoop");
-registry.register("invalid-api-version", APIVersion, "APIVersion");
-registry.register("missing-auto-layout", AutoLayout, "AutoLayout");
-registry.register("unclear-api-naming", CopyAPIName, "CopyAPIName");
-registry.register("excessive-cyclomatic-complexity", CyclomaticComplexity, "CyclomaticComplexity");
-registry.register("dml-in-loop", DMLStatementInLoop, "DMLStatementInLoop");
-registry.register("duplicate-dml", DuplicateDMLOperation, "DuplicateDMLOperation");
-registry.register("missing-flow-description", FlowDescription, "FlowDescription");
-registry.register("invalid-naming-convention", FlowName, "FlowName");
-registry.register("get-record-all-fields", GetRecordAllFields, "GetRecordAllFields");
-registry.register("hardcoded-id", HardcodedId, "HardcodedId");
-registry.register("hardcoded-url", HardcodedUrl, "HardcodedUrl");
-registry.register("inactive-flow", InactiveFlow, "InactiveFlow");
-registry.register("missing-fault-path", MissingFaultPath, "MissingFaultPath");
-registry.register("missing-null-handler", MissingNullHandler, "MissingNullHandler");
-registry.register("process-builder-usage", ProcessBuilder, "ProcessBuilder");
-registry.register("recursive-record-update", RecursiveAfterUpdate, "RecursiveAfterUpdate");
-registry.register("same-record-field-updates", SameRecordFieldUpdates, "SameRecordFieldUpdates");
-registry.register("soql-in-loop", SOQLQueryInLoop, "SOQLQueryInLoop");
-registry.register("unspecified-trigger-order", TriggerOrder, "TriggerOrder");
-registry.register("unreachable-element", UnconnectedElement, "UnconnectedElement");
-registry.register("unsafe-running-context", UnsafeRunningContext, "UnsafeRunningContext");
-registry.register("unused-variable", UnusedVariable, "UnusedVariable");
-
-registry.register("missing-metadata-description", MissingMetadataDescription, "MissingMetadataDescription", true);
-registry.register("missing-record-trigger-filter", MissingRecordTriggerFilter, "MissingFilterRecordTrigger", true);
-registry.register("transform-instead-of-loop", TransformInsteadOfLoop, "TransformInsteadOfLoop", true);
-registry.register("record-id-as-string", RecordIdAsString, "RecordIdAsString", true);
-registry.register("hardcoded-secret", HardcodedSecret, "HardcodedSecret", true);
-
-export const ruleRegistry = registry;

package/src/main/config/VariableIcons.ts

@@ -1,57 +0,0 @@
-/**
- * Icon configuration for flow variable types.
- * Includes icons for variable subtypes and boolean states.
- */
-
-export interface VariableIconConfig {
-  // Variable subtype icons
-  subtypes: {
-    [subtype: string]: string;
-  };
-  // Boolean state icons (for isCollection, isInput, isOutput)
-  boolean: {
-    true: string;
-    false: string;
-  };
-}
-
-/**
- * Default icons using emoji (recommended for modern environments)
- */
-export const DEFAULT_VARIABLE_ICONS: VariableIconConfig = {
-  subtypes: {
-    variables: '\uD83D\uDCCA',        // BAR CHART (data/variable)
-    constants: '\uD83D\uDD12',        // LOCK (constant/immutable)
-    formulas: '\uD83E\uDDEE',         // ABACUS (calculation)
-    choices: '\uD83D\uDCCB',          // CLIPBOARD (picklist/choices)
-    dynamicChoiceSets: '\uD83D\uDD04', // ARROWS (dynamic)
-  },
-  boolean: {
-    true: '\u2705',                   // CHECK MARK
-    false: '\u2B1C',                  // WHITE SQUARE
-  }
-};
-
-/**
- * ASCII fallback icons (for environments without emoji support)
- */
-export const ASCII_VARIABLE_ICONS: VariableIconConfig = {
-  subtypes: {
-    variables: '[V]',
-    constants: '[C]',
-    formulas: '[F]',
-    choices: '[CH]',
-    dynamicChoiceSets: '[D]',
-  },
-  boolean: {
-    true: '[X]',
-    false: '[ ]',
-  }
-};
-
-/**
- * Get default variable icon config
- */
-export function getDefaultVariableIconConfig(): VariableIconConfig {
-  return DEFAULT_VARIABLE_ICONS;
-}

package/src/main/enums/MetadataTypes.ts

@@ -1,6 +0,0 @@
-export enum MetaType {
-  ATTRIBUTE = "attribute",
-  VARIABLE = "variable",
-  RESOURCE = "resource",
-  NODE = "node"
-}