gremlin 3.8.0 → 4.0.0-beta.2

package/build/esm/language/translator/TranslateVisitor.js

@@ -0,0 +1,386 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { GremlinLexer } from '../grammar/GremlinLexer.js';
+/**
+ * Base visitor for translating Gremlin queries. Mirrors the Java TranslateVisitor.
+ * Makes no changes to input except:
+ * - Normalizes whitespace
+ * - Normalizes numeric suffixes to lower case
+ * - Makes anonymous traversals explicit with double underscore
+ * - Makes enums explicit with their proper name
+ */
+export default class TranslateVisitor {
+    graphTraversalSourceName;
+    sb = [];
+    parameters = new Set();
+    constructor(graphTraversalSourceName = 'g') {
+        this.graphTraversalSourceName = graphTraversalSourceName;
+    }
+    getTranslated() {
+        return this.sb.join('');
+    }
+    getParameters() {
+        return this.parameters;
+    }
+    processGremlinSymbol(step) {
+        return step;
+    }
+    appendArgumentSeparator() {
+        this.sb.push(', ');
+    }
+    appendStepSeparator() {
+        this.sb.push('.');
+    }
+    appendStepOpen() {
+        this.sb.push('(');
+    }
+    appendStepClose() {
+        this.sb.push(')');
+    }
+    appendAnonymousSpawn() {
+        this.sb.push('__.');
+    }
+    visit(tree) {
+        if (tree == null)
+            return;
+        // antlr-ng does not generate accept() overrides per context class —
+        // ParserRuleContext.accept() always calls visitChildren, never dispatching to
+        // the specific visitXxx method. We perform the dispatch ourselves here by
+        // mapping the context class name (e.g. StringLiteralContext) to the
+        // corresponding visitor method (e.g. visitStringLiteral).
+        const className = tree?.constructor?.name ?? '';
+        if (className.endsWith('Context')) {
+            const methodName = 'visit' + className.slice(0, -'Context'.length);
+            const method = this[methodName];
+            if (typeof method === 'function') {
+                method.call(this, tree);
+                return;
+            }
+        }
+        // No specific visitor method found — fall through to accept() which calls
+        // visitChildren for rule contexts, visitTerminal for terminals.
+        tree.accept(this);
+    }
+    visitChildren(node) {
+        const n = node.getChildCount();
+        for (let i = 0; i < n; i++) {
+            this.visit(node.getChild(i));
+        }
+    }
+    getCardinalityFunctionClass() {
+        return 'Cardinality';
+    }
+    static removeFirstAndLastCharacters(text) {
+        return text != null && text.length > 0 ? text.substring(1, text.length - 1) : '';
+    }
+    handleStringLiteralText(text) {
+        this.sb.push('"');
+        this.sb.push(text);
+        this.sb.push('"');
+    }
+    appendExplicitNaming(txt, prefix) {
+        if (!txt.startsWith(prefix + '.')) {
+            this.sb.push(this.processGremlinSymbol(prefix));
+            this.sb.push('.');
+            this.sb.push(this.processGremlinSymbol(txt));
+        }
+        else {
+            const parts = txt.split('.');
+            this.sb.push(this.processGremlinSymbol(parts[0]));
+            this.sb.push('.');
+            this.sb.push(this.processGremlinSymbol(parts[1]));
+        }
+    }
+    visitTerminal(node) {
+        // skip EOF node
+        if (node == null || node.getSymbol().type === -1)
+            return;
+        // TRAVERSAL_ROOT is the traversal source token (e.g. 'g') — always output as-is,
+        // never subject to processGremlinSymbol (which may capitalize it in some dialects).
+        if (node.getSymbol().type === GremlinLexer.TRAVERSAL_ROOT) {
+            this.sb.push(this.graphTraversalSourceName);
+            return;
+        }
+        const terminal = node.getSymbol().text ?? '';
+        switch (terminal) {
+            case '(':
+                this.appendStepOpen();
+                break;
+            case ')':
+                this.appendStepClose();
+                break;
+            case ',':
+                this.appendArgumentSeparator();
+                break;
+            case '.':
+                this.appendStepSeparator();
+                break;
+            case 'new':
+                this.sb.push('new');
+                if (!(node.parent?.constructor?.name === 'MapKeyContext')) {
+                    this.sb.push(' ');
+                }
+                break;
+            default:
+                this.sb.push(this.processGremlinSymbol(terminal));
+        }
+    }
+    visitErrorNode(_node) {
+        // no-op
+    }
+    visitTraversalSource(ctx) {
+        this.sb.push(this.graphTraversalSourceName);
+        // child counts more than 1 means there is a step separator and a traversal source method
+        if (ctx.getChildCount() > 1) {
+            if (ctx.getChild(0).getChildCount() > 1) {
+                this.appendStepSeparator();
+                this.visitTraversalSourceSelfMethod(ctx.getChild(0).getChild(2));
+            }
+            this.appendStepSeparator();
+            this.visitTraversalSourceSelfMethod(ctx.getChild(2));
+        }
+    }
+    visitTraversalSourceSelfMethod(ctx) {
+        this.visitChildren(ctx);
+    }
+    visitNestedTraversal(ctx) {
+        if (ctx.ANON_TRAVERSAL_ROOT() == null) {
+            this.appendAnonymousSpawn();
+        }
+        this.visitChildren(ctx);
+    }
+    visitTraversalScope(ctx) {
+        this.appendExplicitNaming(ctx.getText(), 'Scope');
+    }
+    visitTraversalT(ctx) {
+        this.appendExplicitNaming(ctx.getText(), 'T');
+    }
+    visitTraversalTShort(ctx) {
+        this.appendExplicitNaming(ctx.getText(), 'T');
+    }
+    visitTraversalTLong(ctx) {
+        this.appendExplicitNaming(ctx.getText(), 'T');
+    }
+    visitTraversalMerge(ctx) {
+        this.appendExplicitNaming(ctx.getText(), 'Merge');
+    }
+    visitTraversalOrder(ctx) {
+        this.appendExplicitNaming(ctx.getText(), 'Order');
+    }
+    visitTraversalBarrier(ctx) {
+        this.appendExplicitNaming(ctx.getText(), 'Barrier');
+    }
+    visitTraversalDirection(ctx) {
+        this.appendExplicitNaming(ctx.getText(), 'Direction');
+    }
+    visitTraversalDirectionShort(ctx) {
+        this.appendExplicitNaming(ctx.getText(), 'Direction');
+    }
+    visitTraversalDirectionLong(ctx) {
+        this.appendExplicitNaming(ctx.getText(), 'Direction');
+    }
+    visitTraversalCardinality(ctx) {
+        if (ctx.LPAREN() != null && ctx.RPAREN() != null) {
+            const idx = ctx.K_CARDINALITY() != null ? 2 : 0;
+            const txt = ctx.getChild(idx).getText();
+            this.appendExplicitNaming(txt, this.getCardinalityFunctionClass());
+            this.appendStepOpen();
+            this.visit(ctx.genericLiteral());
+            this.appendStepClose();
+        }
+        else {
+            this.appendExplicitNaming(ctx.getText(), 'Cardinality');
+        }
+    }
+    visitTraversalColumn(ctx) {
+        this.appendExplicitNaming(ctx.getText(), 'Column');
+    }
+    visitTraversalPop(ctx) {
+        this.appendExplicitNaming(ctx.getText(), 'Pop');
+    }
+    visitTraversalOperator(ctx) {
+        this.appendExplicitNaming(ctx.getText(), 'Operator');
+    }
+    visitTraversalPick(ctx) {
+        this.appendExplicitNaming(ctx.getText(), 'Pick');
+    }
+    visitTraversalDT(ctx) {
+        this.appendExplicitNaming(ctx.getText(), 'DT');
+    }
+    visitTraversalGType(ctx) {
+        this.appendExplicitNaming(ctx.getText(), 'GType');
+    }
+    visitTraversalPredicate(ctx) {
+        switch (ctx.getChildCount()) {
+            case 1:
+                this.visit(ctx.getChild(0));
+                break;
+            case 5:
+                // handle negate of P
+                this.visit(ctx.getChild(0));
+                this.sb.push('.');
+                this.sb.push(this.processGremlinSymbol('negate'));
+                this.sb.push('()');
+                break;
+            case 6:
+                // handle and/or predicates
+                this.visit(ctx.getChild(0));
+                this.sb.push('.');
+                this.sb.push(this.processGremlinSymbol(ctx.getChild(2).getText()));
+                this.sb.push('(');
+                this.visit(ctx.getChild(4));
+                this.sb.push(')');
+                break;
+        }
+    }
+    visitP(ctx, pClass, methodName) {
+        this.sb.push(pClass);
+        this.appendStepSeparator();
+        this.sb.push(this.processGremlinSymbol(methodName));
+        this.appendStepOpen();
+        const children = [];
+        for (let i = 0; i < ctx.getChildCount(); i++) {
+            const child = ctx.getChild(i);
+            const name = child.constructor?.name ?? '';
+            if (name === 'GenericArgumentContext' ||
+                name === 'GenericArgumentVarargsContext' ||
+                name === 'StringArgumentContext' ||
+                name === 'StringLiteralContext' ||
+                name === 'TraversalGTypeContext' ||
+                name === 'TraversalPredicateContext') {
+                children.push(child);
+            }
+        }
+        for (let ix = 0; ix < children.length; ix++) {
+            this.visit(children[ix]);
+            if (ix < children.length - 1) {
+                this.appendArgumentSeparator();
+            }
+        }
+        this.appendStepClose();
+    }
+    visitTraversalPredicate_eq(ctx) { this.visitP(ctx, 'P', 'eq'); }
+    visitTraversalPredicate_neq(ctx) { this.visitP(ctx, 'P', 'neq'); }
+    visitTraversalPredicate_lt(ctx) { this.visitP(ctx, 'P', 'lt'); }
+    visitTraversalPredicate_lte(ctx) { this.visitP(ctx, 'P', 'lte'); }
+    visitTraversalPredicate_gt(ctx) { this.visitP(ctx, 'P', 'gt'); }
+    visitTraversalPredicate_gte(ctx) { this.visitP(ctx, 'P', 'gte'); }
+    visitTraversalPredicate_inside(ctx) { this.visitP(ctx, 'P', 'inside'); }
+    visitTraversalPredicate_outside(ctx) { this.visitP(ctx, 'P', 'outside'); }
+    visitTraversalPredicate_between(ctx) { this.visitP(ctx, 'P', 'between'); }
+    visitTraversalPredicate_within(ctx) { this.visitP(ctx, 'P', 'within'); }
+    visitTraversalPredicate_without(ctx) { this.visitP(ctx, 'P', 'without'); }
+    visitTraversalPredicate_typeOf(ctx) { this.visitP(ctx, 'P', 'typeOf'); }
+    visitTraversalPredicate_not(ctx) { this.visitP(ctx, 'P', 'not'); }
+    visitTraversalPredicate_containing(ctx) { this.visitP(ctx, 'TextP', 'containing'); }
+    visitTraversalPredicate_notContaining(ctx) { this.visitP(ctx, 'TextP', 'notContaining'); }
+    visitTraversalPredicate_startingWith(ctx) { this.visitP(ctx, 'TextP', 'startingWith'); }
+    visitTraversalPredicate_notStartingWith(ctx) { this.visitP(ctx, 'TextP', 'notStartingWith'); }
+    visitTraversalPredicate_endingWith(ctx) { this.visitP(ctx, 'TextP', 'endingWith'); }
+    visitTraversalPredicate_notEndingWith(ctx) { this.visitP(ctx, 'TextP', 'notEndingWith'); }
+    visitTraversalPredicate_regex(ctx) { this.visitP(ctx, 'TextP', 'regex'); }
+    visitTraversalPredicate_notRegex(ctx) { this.visitP(ctx, 'TextP', 'notRegex'); }
+    visitBooleanArgument(ctx) {
+        if (ctx.booleanLiteral() != null) {
+            this.visitBooleanLiteral(ctx.booleanLiteral());
+        }
+        else {
+            this.visitVariable(ctx.variable());
+        }
+    }
+    visitGenericArgument(ctx) {
+        if (ctx.genericLiteral() != null) {
+            this.visitGenericLiteral(ctx.genericLiteral());
+        }
+        else {
+            this.visitVariable(ctx.variable());
+        }
+    }
+    visitGenericLiteral(ctx) {
+        this.visitChildren(ctx);
+    }
+    visitIntegerLiteral(ctx) {
+        this.sb.push(ctx.getText().toLowerCase());
+    }
+    visitFloatLiteral(ctx) {
+        if (ctx.infLiteral() != null) {
+            this.visit(ctx.infLiteral());
+            return;
+        }
+        if (ctx.nanLiteral() != null) {
+            this.visit(ctx.nanLiteral());
+            return;
+        }
+        this.sb.push(ctx.getText().toLowerCase());
+    }
+    visitBooleanLiteral(ctx) {
+        this.sb.push(ctx.getText());
+    }
+    visitNullLiteral(ctx) {
+        this.sb.push(ctx.getText());
+    }
+    visitNanLiteral(ctx) {
+        this.sb.push(ctx.getText());
+    }
+    visitInfLiteral(ctx) {
+        this.sb.push(ctx.getText());
+    }
+    visitUuidLiteral(ctx) {
+        this.sb.push(ctx.getText());
+    }
+    visitStringLiteral(ctx) {
+        const text = TranslateVisitor.removeFirstAndLastCharacters(ctx.getText());
+        this.handleStringLiteralText(text);
+    }
+    visitStringNullableLiteral(ctx) {
+        if (ctx.getText() === 'null') {
+            this.sb.push('null');
+        }
+        else {
+            const text = TranslateVisitor.removeFirstAndLastCharacters(ctx.getText());
+            this.handleStringLiteralText(text);
+        }
+    }
+    visitNakedKey(ctx) {
+        this.handleStringLiteralText(ctx.getText());
+    }
+    visitVariable(ctx) {
+        const varName = ctx.getText();
+        this.sb.push(varName);
+        this.parameters.add(varName);
+    }
+    visitKeyword(ctx) {
+        const keyword = ctx.getText();
+        if (ctx.parent?.constructor?.name === 'MapKeyContext' ||
+            ctx.parent?.constructor?.name === 'ConfigurationContext') {
+            this.handleStringLiteralText(keyword);
+        }
+        else {
+            this.sb.push(keyword);
+            this.sb.push(' ');
+        }
+    }
+    visitMapKey(ctx) {
+        const keyIndex = (ctx.LPAREN() != null && ctx.RPAREN() != null) ? 1 : 0;
+        this.visit(ctx.getChild(keyIndex));
+    }
+    visitMapEntry(ctx) {
+        this.visitChildren(ctx);
+    }
+}

package/build/esm/language/translator/Translation.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Holds the result of a Gremlin translation.
+ */
+export declare class Translation {
+    readonly original: string;
+    readonly translated: string;
+    readonly parameters: ReadonlySet<string>;
+    constructor(original: string, translated: string, parameters: ReadonlySet<string>);
+    getOriginal(): string;
+    getTranslated(): string;
+    getParameters(): ReadonlySet<string>;
+    toString(): string;
+}

package/build/esm/language/translator/Translation.js

@@ -0,0 +1,43 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+/**
+ * Holds the result of a Gremlin translation.
+ */
+export class Translation {
+    original;
+    translated;
+    parameters;
+    constructor(original, translated, parameters) {
+        this.original = original;
+        this.translated = translated;
+        this.parameters = parameters;
+    }
+    getOriginal() {
+        return this.original;
+    }
+    getTranslated() {
+        return this.translated;
+    }
+    getParameters() {
+        return this.parameters;
+    }
+    toString() {
+        return this.translated;
+    }
+}

package/build/esm/language/translator/Translator.d.ts

@@ -0,0 +1,24 @@
+import TranslateVisitor from './TranslateVisitor.js';
+import JavascriptTranslateVisitor from './JavascriptTranslateVisitor.js';
+import PythonTranslateVisitor from './PythonTranslateVisitor.js';
+import GoTranslateVisitor from './GoTranslateVisitor.js';
+import DotNetTranslateVisitor from './DotNetTranslateVisitor.js';
+import JavaTranslateVisitor from './JavaTranslateVisitor.js';
+import GroovyTranslateVisitor from './GroovyTranslateVisitor.js';
+import AnonymizedTranslateVisitor from './AnonymizedTranslateVisitor.js';
+export type TranslatorFactory = (sourceName: string) => TranslateVisitor;
+/**
+ * Extensible registry of translator factories. New languages are added here
+ * without modifying any other file.
+ */
+export declare const Translator: {
+    CANONICAL: (sourceName: string) => TranslateVisitor;
+    JAVASCRIPT: (sourceName: string) => JavascriptTranslateVisitor;
+    PYTHON: (sourceName: string) => PythonTranslateVisitor;
+    GO: (sourceName: string) => GoTranslateVisitor;
+    DOTNET: (sourceName: string) => DotNetTranslateVisitor;
+    JAVA: (sourceName: string) => JavaTranslateVisitor;
+    GROOVY: (sourceName: string) => GroovyTranslateVisitor;
+    ANONYMIZED: (sourceName: string) => AnonymizedTranslateVisitor;
+};
+export type TranslatorKey = keyof typeof Translator;

package/build/esm/language/translator/Translator.js

@@ -0,0 +1,40 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import TranslateVisitor from './TranslateVisitor.js';
+import JavascriptTranslateVisitor from './JavascriptTranslateVisitor.js';
+import PythonTranslateVisitor from './PythonTranslateVisitor.js';
+import GoTranslateVisitor from './GoTranslateVisitor.js';
+import DotNetTranslateVisitor from './DotNetTranslateVisitor.js';
+import JavaTranslateVisitor from './JavaTranslateVisitor.js';
+import GroovyTranslateVisitor from './GroovyTranslateVisitor.js';
+import AnonymizedTranslateVisitor from './AnonymizedTranslateVisitor.js';
+/**
+ * Extensible registry of translator factories. New languages are added here
+ * without modifying any other file.
+ */
+export const Translator = {
+    CANONICAL: (sourceName) => new TranslateVisitor(sourceName),
+    JAVASCRIPT: (sourceName) => new JavascriptTranslateVisitor(sourceName),
+    PYTHON: (sourceName) => new PythonTranslateVisitor(sourceName),
+    GO: (sourceName) => new GoTranslateVisitor(sourceName),
+    DOTNET: (sourceName) => new DotNetTranslateVisitor(sourceName),
+    JAVA: (sourceName) => new JavaTranslateVisitor(sourceName),
+    GROOVY: (sourceName) => new GroovyTranslateVisitor(sourceName),
+    ANONYMIZED: (sourceName) => new AnonymizedTranslateVisitor(sourceName),
+};

package/build/esm/language/translator/TranslatorException.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Thrown when a Gremlin string cannot be translated to the target language.
+ */
+export declare class TranslatorException extends Error {
+    constructor(message: string);
+}

package/build/esm/language/translator/TranslatorException.js

@@ -0,0 +1,27 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+/**
+ * Thrown when a Gremlin string cannot be translated to the target language.
+ */
+export class TranslatorException extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'TranslatorException';
+    }
+}

package/build/esm/process/anonymous-traversal.d.ts

@@ -0,0 +1,40 @@
+import { RemoteConnection } from '../driver/remote-connection.js';
+import { GraphTraversalSource, GraphTraversal } from './graph-traversal.js';
+/**
+ * Provides a unified way to construct a <code>TraversalSource</code> from the perspective of the traversal. In this
+ * syntax the user is creating the source and binding it to a reference which is either an existing <code>Graph</code>
+ * instance or a <code>RemoteConnection</code>.
+ */
+export default class AnonymousTraversalSource {
+    readonly traversalSourceClass?: typeof GraphTraversalSource | undefined;
+    readonly traversalClass?: typeof GraphTraversal | undefined;
+    /**
+     * Creates a new instance of `AnonymousTraversalSource`.
+     * @param {Function} [traversalSourceClass] Optional `GraphTraversalSource` constructor.
+     * @param {Function} [traversalClass] Optional `GraphTraversal` constructor.
+     */
+    constructor(traversalSourceClass?: typeof GraphTraversalSource | undefined, traversalClass?: typeof GraphTraversal | undefined);
+    /**
+     * Constructs an `AnonymousTraversalSource` which will then be configured to spawn a
+     * {@link GraphTraversalSource}.
+     * @param {Function} [traversalSourceClass] Optional `GraphTraversalSource` constructor.
+     * @param {Function} [traversalClass] Optional `GraphTraversalSource` constructor.
+     * @returns {AnonymousTraversalSource}.
+     */
+    static traversal(traversalSourceClass?: typeof GraphTraversalSource, traversalClass?: typeof GraphTraversal): AnonymousTraversalSource;
+    /**
+     * Creates a {@link GraphTraversalSource} binding a {@link RemoteConnection} to a remote {@link Graph} instances as its
+     * reference so that traversals spawned from it will execute over that reference.
+     * @param {RemoteConnection} connection
+     * @return {GraphTraversalSource}
+     */
+    with_(connection: RemoteConnection): GraphTraversalSource;
+    /**
+     * Creates a {@link GraphTraversalSource} binding a {@link RemoteConnection} to a remote {@link Graph} instances as its
+     * reference so that traversals spawned from it will execute over that reference.
+     * @param {RemoteConnection} remoteConnection
+     * @return {GraphTraversalSource}
+     * @deprecated As of release 3.8.0, prefer {@link with_}.
+     */
+    withRemote(remoteConnection: RemoteConnection): GraphTraversalSource;
+}

package/build/esm/process/anonymous-traversal.js

@@ -0,0 +1,72 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+import { RemoteStrategy } from '../driver/remote-connection.js';
+import { Graph } from '../structure/graph.js';
+import { GraphTraversalSource, GraphTraversal } from './graph-traversal.js';
+import { TraversalStrategies } from './traversal-strategy.js';
+import GremlinLang from './gremlin-lang.js';
+/**
+ * Provides a unified way to construct a <code>TraversalSource</code> from the perspective of the traversal. In this
+ * syntax the user is creating the source and binding it to a reference which is either an existing <code>Graph</code>
+ * instance or a <code>RemoteConnection</code>.
+ */
+export default class AnonymousTraversalSource {
+    traversalSourceClass;
+    traversalClass;
+    /**
+     * Creates a new instance of `AnonymousTraversalSource`.
+     * @param {Function} [traversalSourceClass] Optional `GraphTraversalSource` constructor.
+     * @param {Function} [traversalClass] Optional `GraphTraversal` constructor.
+     */
+    constructor(traversalSourceClass, traversalClass) {
+        this.traversalSourceClass = traversalSourceClass;
+        this.traversalClass = traversalClass;
+    }
+    /**
+     * Constructs an `AnonymousTraversalSource` which will then be configured to spawn a
+     * {@link GraphTraversalSource}.
+     * @param {Function} [traversalSourceClass] Optional `GraphTraversalSource` constructor.
+     * @param {Function} [traversalClass] Optional `GraphTraversalSource` constructor.
+     * @returns {AnonymousTraversalSource}.
+     */
+    static traversal(traversalSourceClass, traversalClass) {
+        return new AnonymousTraversalSource(traversalSourceClass || GraphTraversalSource, traversalClass || GraphTraversal);
+    }
+    /**
+     * Creates a {@link GraphTraversalSource} binding a {@link RemoteConnection} to a remote {@link Graph} instances as its
+     * reference so that traversals spawned from it will execute over that reference.
+     * @param {RemoteConnection} connection
+     * @return {GraphTraversalSource}
+     */
+    with_(connection) {
+        const traversalStrategies = new TraversalStrategies();
+        traversalStrategies.addStrategy(new RemoteStrategy(connection));
+        return new this.traversalSourceClass(new Graph(), traversalStrategies, new GremlinLang(), this.traversalSourceClass, this.traversalClass);
+    }
+    /**
+     * Creates a {@link GraphTraversalSource} binding a {@link RemoteConnection} to a remote {@link Graph} instances as its
+     * reference so that traversals spawned from it will execute over that reference.
+     * @param {RemoteConnection} remoteConnection
+     * @return {GraphTraversalSource}
+     * @deprecated As of release 3.8.0, prefer {@link with_}.
+     */
+    withRemote(remoteConnection) {
+        return this.with_(remoteConnection);
+    }
+}