elo-utils README

This extension provides complete TypeScript IntelliSense for ELO JavaScript development with the Rhino Engine.

TypeScript classes are parsed from .jar files and created as .d.ts files.

The Extension is 100% Vibecoded...

Features

Native TypeScript IntelliSense

The extension uses exclusively TypeScript declaration files (.d.ts) for IntelliSense - no more custom providers. This offers:

IntelliSense - Examples

ELO Java API Classes

Complete access to all ELO Java API classes with automatic type inference:

// ✓ new Expression - Type is automatically detected
const sord = new Sord();
sord.getName();       // IntelliSense shows all Sord methods
sord.setName("Test"); // With parameter hints

// ✓ Constant classes (static members)
const mbAll = SordC.mbAll;
const noLock = LockC.NO;

// ✓ Global variables (predefined)
ixConnect.ix().checkoutSord("123", SordC.mbAll, LockC.NO);
log.info("Message");

Method Return Type Inference

TypeScript automatically detects return types - IntelliSense works for all method calls:

// ✓ checkoutSord() returns Sord
const checkedOutSord = ixConnect.ix().checkoutSord("123", SordC.mbAll, LockC.NO);
checkedOutSord.getName();     // IntelliSense shows all Sord methods
checkedOutSord.getParentId(); // Type automatically detected

// ✓ findFirstSords() returns FindResult
const findResult = ixConnect.ix().findFirstSords(findInfo, 100, SordC.mbAll);
findResult.getIds();          // IntelliSense shows FindResult methods
findResult.getSords();        // Array of Sord objects
findResult.isMoreResults();   // boolean

ixConnect.ix().checkoutAspect(aspectId, aspectZ, lockZ);
ixConnect.ix().checkoutWorkFlow(flowId, typeZ, diagramZ, lockZ);
ixConnect.ix().deleteSord(parentId, objId, unlockZ, deleteOptions);

// ✓ Nested calls
const sords = ixConnect.ix()
        .findFirstSords(findInfo, 100, SordC.mbAll)
  .getSords(); // sords is Sord[] - Type inference for array elements

sol.define() Classes (Auto-Update)

The extension scans all workspace folders for sol.define() calls and automatically generates TypeScript definitions.

🔄 Automatic Regeneration: When you modify .js files, the type definitions are automatically updated and IntelliSense refreshes automatically.

Supported Features:

• ✅ Singleton and instance classes
• ✅ Nested namespaces (sol.common.Utils)
• ✅ Nested properties (testProp.nested.deep)
• ✅ JSDoc documentation (classes, methods, properties)
• ✅ Parameter and return types from JSDoc
• ✅ Object-literal IntelliSense from nested params (e.g. options.exactMatch)
• ✅ sol.create() type overloads

Nested parameter typing supports both explicit JSDoc (@param options.exactMatch) and AST fallback inference from method body usage.

Example 1: Singleton Class

// lib_syn.common.Utils.js
/**
 * Utility functions for common operations
 * This is a singleton class
 */
sol.define("sol.common.Utils", {
    singleton: true,
    
    /**
     * Test object with nested properties
     * @property {Object}
     */
    testProp: {
        test: "value",
        nested: {
            deep: "nested value"
        },
        count: 42
    },
    
    /**
     * Concatenates number and string
     * @param {number} num - A number
     * @param {string} str - A string
     * @returns {string} Concatenated result
     */
    doSomething(num, str) {
        return num + str;
    }
});

Usage with IntelliSense:

// ✓ Namespace navigation
sol.common.Utils.doSomething(1, "test"); // IntelliSense shows parameter hints

// ✓ Nested properties
const value = sol.common.Utils.testProp.nested.deep; // IntelliSense for every level

// ✓ Hover shows JSDoc
// Hover over "Utils" shows: "Utility functions for common operations..."

Example 2: Instance Class

/**
 * Process handler for data operations
 */
sol.define("sol.functions.Processor", {
    /**
     * Counter property
     * @property {number}
     */
    counter: 0,
    
    /**
     * Process input data
     * @param {string} input - Input to process
     * @returns {string} Processed result
     */
    process(input) {
        return input.toUpperCase();
    }
});

Usage with Type Inference:

// ✓ sol.create() with type overload
const proc = sol.create("sol.functions.Processor");
//    ^^^^ Type is automatically: syn.functions.Processor

proc.process("test");  // IntelliSense shows methods
proc.counter = 5;      // IntelliSense shows properties

Open ELO JavaDoc Documentation

Quick access to the official ELO JavaDoc documentation:

Command:

• Ctrl+Shift+P → "ELO Utils: Open JavaDoc Documentation"
• Opens: https://forum.elo.com/javadoc/

The documentation opens in an external browser and shows all ELO Java API classes, methods and their complete descriptions.

How It Works

TypeScript Server Plugin (Automatic Setup)

This extension ships a TypeScript server plugin that injects ELO declaration files into JavaScript and TypeScript projects.

✅ Works in inferred projects (single-file mode)
✅ Works in workspace projects (jsconfig.json/tsconfig.json)
✅ No manual typeRoots setup for standard usage

Single-File Mode (No Workspace)

In single-file mode, the TypeScript server plugin still contributes global declarations, so IntelliSense is available without creating a jsconfig.json.

Verifying the Plugin

The extension logs startup status in the "ELO Utils" output panel. You can also enable TypeScript server logging and check for plugin initialization messages.

Troubleshooting

IntelliSense Not Working

1. Check Extension Output
   • View → Output → Select "ELO Utils" from dropdown

• Look for plugin-mode startup messages
• Verify type definition files are found

2. Verify File Language Mode

   • Check bottom-right corner of VS Code
   • Should show "JavaScript" or "TypeScript"
   • If not, click and select the correct language

3. Check for Conflicting Config

• If workspace tsconfig.json/jsconfig.json is very restrictive, ensure it doesn't exclude active files

VS Code Suggestion Ordering

Problem: "Word" suggestions sometimes appear before TypeScript suggestions.

Solution: Disable word-based suggestions in settings:

• Ctrl+, → Search "suggest.showWords"
• Disable "Show Words" for better TypeScript suggestions

Go to setting

Commit Character Conflict

Problem: With sol. the . is interpreted as a commit character and incorrectly accepts a suggestion.

Solution: Disable commit characters:

• Ctrl+, → Search "acceptSuggestionOnCommitCharacter"
• Disable this option

Go to setting

Soft Lint Hints (JSDoc Warnings)

Short rules used by the built-in soft linting:

• General rules (all JavaScript files):

  • Warn when a function is longer than the configured threshold (default: 80 lines).
  • Warn when a function has no JSDoc.

• General rule settings:

  • elo-utils.linting.enableGeneralRules (default: true) disables/enables both general rules.
  • elo-utils.linting.maxFunctionLines (default: 80) sets the function length warning threshold.
  • elo-utils.linting.maxClassLines (legacy fallback) is used only if maxFunctionLines is not set.
  • elo-utils.linting.fileIncludeRegex (default: empty) limits linting to files whose full path matches the regex.

• File filter: warnings are skipped for file names starting with sol or lib_sol.

• Scope: only sol.define("...", { ... }) blocks are checked.

• Class JSDoc must include: description, @class, @author, one of @eloall/@eloix/@eloas (also @elowf, @elojc accepted).

• If singleton: true, class JSDoc must also include @singleton.

• Methods: all methods need JSDoc except initialize and process methods without parameters and return values.

• Method tags: all function params need matching @param; @returns is required only when a value is returned.

• Properties: non-function properties need JSDoc with @property {<type>} <name>.

• Property JSDoc exceptions: singleton, requiredConfig, extend, mixins.

Valid property examples:

/**
 * @property {Object} _config
 */
_config: undefined,

/**
 * Pfad zur Configdatei
 * @property {string} _configPath path to current config
 */
_configPath: "ARCPATH[...]",

/**
 * @property {Function} logInfo wird überschrieben, wenn ins detaillog gegangen werden soll
 */
logInfo: undefined,

Changelog

1.2.1

• Fixing constant classes to expose property style members (e.g. SordC.mbAll)
• Preventing function methods for constant classes in generated types
• Fixing function call completion to add () on accept (SordC.getMbAll())
• Fixing linting file filter to skip files starting with sol or lib_sol
• Improving performance by reducing redundant regeneration triggers and caching include scans
• Adding maxFunctionLines rule (with maxClassLines as fallback)
• Adding regex based lint file include filtering
• Accepting nested @param names and adding AST fallback for options.* IntelliSense

1.2.0

• Fixing dynamic loading of sol.classes
• Fixing Constants
• sol.class inclusion graph
• make this.scope accessible in sol.define
• changing triggerlogic
• wannabe linting for sol.defined classes that are not starting with an sol

1.1.1 (broken)

• Fixing problems with packagins, so the plugin is loaded

1.1.0 (broken)

• Switching to ts plugin type Injection

1.0.1 (broken)

• Adding icon

1.0.0 (broken)

• Initial Release

Roadmap

Features

1. [ ] Adding