Engine Factory

/**
 * Creates a new GraalJSScriptEngine instance with default configuration
 * @return New ScriptEngine instance
 */
ScriptEngine getScriptEngine();

/**
 * Returns the underlying polyglot engine used by created ScriptEngines
 * This engine is shared across multiple ScriptEngine instances for efficiency
 * @return GraalVM polyglot Engine instance
 */
Engine getPolyglotEngine();

// Service discovery approach
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngineFactory factory = manager.getEngineByName("js").getFactory();
ScriptEngine engine1 = factory.getScriptEngine();
ScriptEngine engine2 = factory.getScriptEngine();

// Direct factory usage
GraalJSEngineFactory factory = new GraalJSEngineFactory();
ScriptEngine engine = factory.getScriptEngine();

// Access underlying polyglot engine
Engine polyglotEngine = ((GraalJSEngineFactory) factory).getPolyglotEngine();

/**
 * Returns the display name of the script engine
 * @return "Graal.js"
 */
String getEngineName();

/**
 * Returns the version of the script engine
 * @return GraalVM version string
 */
String getEngineVersion();

/**
 * Returns the name of the scripting language
 * @return "ECMAScript"
 */
String getLanguageName();

/**
 * Returns the version of the scripting language
 * @return "ECMAScript 262 Edition 11"
 */
String getLanguageVersion();

/**
 * Returns list of supported engine names/aliases for service discovery
 * @return List of engine name strings
 */
List<String> getNames();

/**
 * Returns list of supported MIME types
 * @return List of MIME type strings
 */
List<String> getMimeTypes();

/**
 * Returns list of supported file extensions
 * @return List of file extension strings
 */
List<String> getExtensions();

GraalJSEngineFactory factory = new GraalJSEngineFactory();

// Get engine information
System.out.println("Engine: " + factory.getEngineName()); // "Graal.js"
System.out.println("Version: " + factory.getEngineVersion()); // "24.2.1"
System.out.println("Language: " + factory.getLanguageName()); // "ECMAScript"

// Check supported formats
List<String> names = factory.getNames();
System.out.println("Supported names: " + names);
// [js, JS, JavaScript, javascript, ECMAScript, ecmascript, ...]

List<String> mimeTypes = factory.getMimeTypes();
System.out.println("MIME types: " + mimeTypes);
// [application/javascript, application/ecmascript, ...]

List<String> extensions = factory.getExtensions();
System.out.println("File extensions: " + extensions); // [js, mjs]

// Service discovery by different names
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine jsEngine = manager.getEngineByName("JavaScript");
ScriptEngine graalEngine = manager.getEngineByName("Graal.js");
ScriptEngine ecmaEngine = manager.getEngineByName("ECMAScript");
// All return GraalJSScriptEngine instances

// Service discovery by MIME type
ScriptEngine mimeEngine = manager.getEngineByMimeType("application/javascript");

// Service discovery by file extension
ScriptEngine extEngine = manager.getEngineByExtension("js");

/**
 * Returns the value of engine-specific parameters
 * @param key Parameter key (ScriptEngine constants)
 * @return Parameter value or null if not supported
 */
Object getParameter(String key);

GraalJSEngineFactory factory = new GraalJSEngineFactory();

// Access standard parameters
String name = (String) factory.getParameter(ScriptEngine.NAME);
System.out.println("Name: " + name); // "javascript"

String engine = (String) factory.getParameter(ScriptEngine.ENGINE);
System.out.println("Engine: " + engine); // "Graal.js"

String version = (String) factory.getParameter(ScriptEngine.ENGINE_VERSION);
System.out.println("Version: " + version); // "24.2.1"

String language = (String) factory.getParameter(ScriptEngine.LANGUAGE);
System.out.println("Language: " + language); // "ECMAScript"

String langVersion = (String) factory.getParameter(ScriptEngine.LANGUAGE_VERSION);
System.out.println("Language Version: " + langVersion); // "ECMAScript 262 Edition 11"

// Unsupported parameters return null
Object unknown = factory.getParameter("unknown.parameter");
System.out.println("Unknown: " + unknown); // null

/**
 * Generates JavaScript method call syntax
 * @param obj Object name
 * @param method Method name
 * @param args Method arguments
 * @return JavaScript method call string
 */
String getMethodCallSyntax(String obj, String method, String... args);

/**
 * Generates JavaScript output statement
 * @param toDisplay Expression to display
 * @return JavaScript print statement
 */
String getOutputStatement(String toDisplay);

/**
 * Combines multiple statements into a JavaScript program
 * @param statements JavaScript statements
 * @return Complete JavaScript program
 */
String getProgram(String... statements);

GraalJSEngineFactory factory = new GraalJSEngineFactory();

// Generate method call syntax
String methodCall = factory.getMethodCallSyntax("obj", "method", "arg1", "arg2");
System.out.println(methodCall); // "obj.method(arg1,arg2)"

String calculatorCall = factory.getMethodCallSyntax("calc", "add", "10", "20");
System.out.println(calculatorCall); // "calc.add(10,20)"

// Generate output statement
String printStatement = factory.getOutputStatement("result");
System.out.println(printStatement); // "print(result)"

String printExpression = factory.getOutputStatement("2 + 3");
System.out.println(printExpression); // "print(2 + 3)"

// Combine statements into program
String program = factory.getProgram(
    "var x = 10",
    "var y = 20", 
    "var sum = x + y",
    "print(sum)"
);
System.out.println(program); // "var x = 10;var y = 20;var sum = x + y;print(sum);"

// Use generated code in scripts
ScriptEngine engine = factory.getScriptEngine();
engine.eval(program); // Prints: 30

com.oracle.truffle.js.scriptengine.GraalJSEngineFactory

// Automatic service discovery
ScriptEngineManager manager = new ScriptEngineManager();

// Discovery by engine name
ScriptEngine engine1 = manager.getEngineByName("js");
ScriptEngine engine2 = manager.getEngineByName("JavaScript");
ScriptEngine engine3 = manager.getEngineByName("Graal.js");

// Discovery by MIME type
ScriptEngine engine4 = manager.getEngineByMimeType("application/javascript");
ScriptEngine engine5 = manager.getEngineByMimeType("text/javascript");

// Discovery by file extension
ScriptEngine engine6 = manager.getEngineByExtension("js");
ScriptEngine engine7 = manager.getEngineByExtension("mjs");

// List all available engines
for (ScriptEngineFactory factory : manager.getEngineFactories()) {
    if (factory instanceof GraalJSEngineFactory) {
        System.out.println("Found GraalJS factory: " + factory.getEngineName());
    }
}

/**
 * Default constructor - creates factory with lazy engine initialization
 */
GraalJSEngineFactory();

/**
 * Constructor with custom polyglot engine
 * @param engine Pre-configured polyglot engine to use
 */
GraalJSEngineFactory(Engine engine);

// Default factory with lazy engine creation
GraalJSEngineFactory defaultFactory = new GraalJSEngineFactory();
ScriptEngine engine1 = defaultFactory.getScriptEngine();

// Factory with custom polyglot engine
Engine customEngine = Engine.newBuilder()
    .allowExperimentalOptions(true)
    .option("engine.MaxCompilationDelay", "10000")
    .build();

GraalJSEngineFactory customFactory = new GraalJSEngineFactory(customEngine);
ScriptEngine engine2 = customFactory.getScriptEngine();

// Multiple engines sharing the same polyglot engine
ScriptEngine engine3 = customFactory.getScriptEngine();
ScriptEngine engine4 = customFactory.getScriptEngine();

// All engines from the same factory share the polyglot engine
assert customFactory.getPolyglotEngine() == customEngine;