@finos/legend-application-repl 0.0.27 → 0.0.29

package/grammar/parser/generated/datacube_filter__parser.ts

@@ -0,0 +1,514 @@
+// Generated from /Users/blacksteed232/Developer/legend/studio/packages/legend-application-repl/grammar/datacube_filter__parser.g4 by ANTLR 4.13.1
+// noinspection ES6UnusedImports,JSUnusedGlobalSymbols,JSUnusedLocalSymbols
+
+import {
+	ATN,
+	ATNDeserializer, DecisionState, DFA, FailedPredicateException,
+	RecognitionException, NoViableAltException, BailErrorStrategy,
+	Parser, ParserATNSimulator,
+	RuleContext, ParserRuleContext, PredictionMode, PredictionContextCache,
+	TerminalNode, RuleNode,
+	Token, TokenStream,
+	Interval, IntervalSet
+} from 'antlr4';
+// for running tests with parameters, TODO: discuss strategy for typed parameters in CI
+// eslint-disable-next-line no-unused-vars
+type int = number;
+
+export default class datacube_filter__parser extends Parser {
+	public static readonly OPERATOR = 1;
+	public static readonly GROUP_OPERATOR_AND = 2;
+	public static readonly GROUP_OPERATOR_OR = 3;
+	public static readonly GROUP_OPEN = 4;
+	public static readonly GROUP_CLOSE = 5;
+	public static readonly NUMBER = 6;
+	public static readonly STRING = 7;
+	public static readonly COLUMN = 8;
+	public static readonly IDENTIFIER = 9;
+	public static readonly WHITESPACE = 10;
+	public static readonly EOF = Token.EOF;
+	public static readonly RULE_filter = 0;
+	public static readonly RULE_condition = 1;
+	public static readonly RULE_column = 2;
+	public static readonly RULE_value = 3;
+	public static readonly RULE_group = 4;
+	public static readonly RULE_groupOperator = 5;
+	public static readonly RULE_groupCondition = 6;
+	public static readonly literalNames: (string | null)[] = [ null, null, 
+                                                            "'&&'", "'||'", 
+                                                            "'('", "')'" ];
+	public static readonly symbolicNames: (string | null)[] = [ null, "OPERATOR", 
+                                                             "GROUP_OPERATOR_AND", 
+                                                             "GROUP_OPERATOR_OR", 
+                                                             "GROUP_OPEN", 
+                                                             "GROUP_CLOSE", 
+                                                             "NUMBER", "STRING", 
+                                                             "COLUMN", "IDENTIFIER", 
+                                                             "WHITESPACE" ];
+	// tslint:disable:no-trailing-whitespace
+	public static readonly ruleNames: string[] = [
+		"filter", "condition", "column", "value", "group", "groupOperator", "groupCondition",
+	];
+	public get grammarFileName(): string { return "datacube_filter__parser.g4"; }
+	public get literalNames(): (string | null)[] { return datacube_filter__parser.literalNames; }
+	public get symbolicNames(): (string | null)[] { return datacube_filter__parser.symbolicNames; }
+	public get ruleNames(): string[] { return datacube_filter__parser.ruleNames; }
+	public get serializedATN(): number[] { return datacube_filter__parser._serializedATN; }
+
+	protected createFailedPredicateException(predicate?: string, message?: string): FailedPredicateException {
+		return new FailedPredicateException(this, predicate, message);
+	}
+
+	constructor(input: TokenStream) {
+		super(input);
+		this._interp = new ParserATNSimulator(this, datacube_filter__parser._ATN, datacube_filter__parser.DecisionsToDFA, new PredictionContextCache());
+	}
+	// @RuleVersion(0)
+	public filter(): FilterContext {
+		let localctx: FilterContext = new FilterContext(this, this._ctx, this.state);
+		this.enterRule(localctx, 0, datacube_filter__parser.RULE_filter);
+		try {
+			this.enterOuterAlt(localctx, 1);
+			{
+			this.state = 16;
+			this._errHandler.sync(this);
+			switch ( this._interp.adaptivePredict(this._input, 0, this._ctx) ) {
+			case 1:
+				{
+				this.state = 14;
+				this.groupCondition();
+				}
+				break;
+			case 2:
+				{
+				this.state = 15;
+				this.group();
+				}
+				break;
+			}
+			this.state = 18;
+			this.match(datacube_filter__parser.EOF);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return localctx;
+	}
+	// @RuleVersion(0)
+	public condition(): ConditionContext {
+		let localctx: ConditionContext = new ConditionContext(this, this._ctx, this.state);
+		this.enterRule(localctx, 2, datacube_filter__parser.RULE_condition);
+		let _la: number;
+		try {
+			this.enterOuterAlt(localctx, 1);
+			{
+			this.state = 20;
+			this.column();
+			this.state = 21;
+			_la = this._input.LA(1);
+			if(!(_la===1 || _la===9)) {
+			this._errHandler.recoverInline(this);
+			}
+			else {
+				this._errHandler.reportMatch(this);
+			    this.consume();
+			}
+			this.state = 23;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			if (_la===6 || _la===7) {
+				{
+				this.state = 22;
+				this.value();
+				}
+			}
+
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return localctx;
+	}
+	// @RuleVersion(0)
+	public column(): ColumnContext {
+		let localctx: ColumnContext = new ColumnContext(this, this._ctx, this.state);
+		this.enterRule(localctx, 4, datacube_filter__parser.RULE_column);
+		try {
+			this.enterOuterAlt(localctx, 1);
+			{
+			this.state = 25;
+			this.match(datacube_filter__parser.COLUMN);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return localctx;
+	}
+	// @RuleVersion(0)
+	public value(): ValueContext {
+		let localctx: ValueContext = new ValueContext(this, this._ctx, this.state);
+		this.enterRule(localctx, 6, datacube_filter__parser.RULE_value);
+		let _la: number;
+		try {
+			this.enterOuterAlt(localctx, 1);
+			{
+			this.state = 27;
+			_la = this._input.LA(1);
+			if(!(_la===6 || _la===7)) {
+			this._errHandler.recoverInline(this);
+			}
+			else {
+				this._errHandler.reportMatch(this);
+			    this.consume();
+			}
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return localctx;
+	}
+	// @RuleVersion(0)
+	public group(): GroupContext {
+		let localctx: GroupContext = new GroupContext(this, this._ctx, this.state);
+		this.enterRule(localctx, 8, datacube_filter__parser.RULE_group);
+		try {
+			this.enterOuterAlt(localctx, 1);
+			{
+			this.state = 29;
+			this.match(datacube_filter__parser.GROUP_OPEN);
+			this.state = 30;
+			this.groupCondition();
+			this.state = 31;
+			this.match(datacube_filter__parser.GROUP_CLOSE);
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return localctx;
+	}
+	// @RuleVersion(0)
+	public groupOperator(): GroupOperatorContext {
+		let localctx: GroupOperatorContext = new GroupOperatorContext(this, this._ctx, this.state);
+		this.enterRule(localctx, 10, datacube_filter__parser.RULE_groupOperator);
+		let _la: number;
+		try {
+			this.enterOuterAlt(localctx, 1);
+			{
+			this.state = 33;
+			_la = this._input.LA(1);
+			if(!(_la===2 || _la===3)) {
+			this._errHandler.recoverInline(this);
+			}
+			else {
+				this._errHandler.reportMatch(this);
+			    this.consume();
+			}
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return localctx;
+	}
+	// @RuleVersion(0)
+	public groupCondition(): GroupConditionContext {
+		let localctx: GroupConditionContext = new GroupConditionContext(this, this._ctx, this.state);
+		this.enterRule(localctx, 12, datacube_filter__parser.RULE_groupCondition);
+		let _la: number;
+		try {
+			this.enterOuterAlt(localctx, 1);
+			{
+			this.state = 37;
+			this._errHandler.sync(this);
+			switch (this._input.LA(1)) {
+			case 8:
+				{
+				this.state = 35;
+				this.condition();
+				}
+				break;
+			case 4:
+				{
+				this.state = 36;
+				this.group();
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+			this.state = 46;
+			this._errHandler.sync(this);
+			_la = this._input.LA(1);
+			while (_la===2 || _la===3) {
+				{
+				{
+				this.state = 39;
+				this.groupOperator();
+				this.state = 42;
+				this._errHandler.sync(this);
+				switch (this._input.LA(1)) {
+				case 8:
+					{
+					this.state = 40;
+					this.condition();
+					}
+					break;
+				case 4:
+					{
+					this.state = 41;
+					this.group();
+					}
+					break;
+				default:
+					throw new NoViableAltException(this);
+				}
+				}
+				}
+				this.state = 48;
+				this._errHandler.sync(this);
+				_la = this._input.LA(1);
+			}
+			}
+		}
+		catch (re) {
+			if (re instanceof RecognitionException) {
+				localctx.exception = re;
+				this._errHandler.reportError(this, re);
+				this._errHandler.recover(this, re);
+			} else {
+				throw re;
+			}
+		}
+		finally {
+			this.exitRule();
+		}
+		return localctx;
+	}
+
+	public static readonly _serializedATN: number[] = [4,1,10,50,2,0,7,0,2,
+	1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7,6,1,0,1,0,3,0,17,8,0,1,0,1,
+	0,1,1,1,1,1,1,3,1,24,8,1,1,2,1,2,1,3,1,3,1,4,1,4,1,4,1,4,1,5,1,5,1,6,1,
+	6,3,6,38,8,6,1,6,1,6,1,6,3,6,43,8,6,5,6,45,8,6,10,6,12,6,48,9,6,1,6,0,0,
+	7,0,2,4,6,8,10,12,0,3,2,0,1,1,9,9,1,0,6,7,1,0,2,3,47,0,16,1,0,0,0,2,20,
+	1,0,0,0,4,25,1,0,0,0,6,27,1,0,0,0,8,29,1,0,0,0,10,33,1,0,0,0,12,37,1,0,
+	0,0,14,17,3,12,6,0,15,17,3,8,4,0,16,14,1,0,0,0,16,15,1,0,0,0,17,18,1,0,
+	0,0,18,19,5,0,0,1,19,1,1,0,0,0,20,21,3,4,2,0,21,23,7,0,0,0,22,24,3,6,3,
+	0,23,22,1,0,0,0,23,24,1,0,0,0,24,3,1,0,0,0,25,26,5,8,0,0,26,5,1,0,0,0,27,
+	28,7,1,0,0,28,7,1,0,0,0,29,30,5,4,0,0,30,31,3,12,6,0,31,32,5,5,0,0,32,9,
+	1,0,0,0,33,34,7,2,0,0,34,11,1,0,0,0,35,38,3,2,1,0,36,38,3,8,4,0,37,35,1,
+	0,0,0,37,36,1,0,0,0,38,46,1,0,0,0,39,42,3,10,5,0,40,43,3,2,1,0,41,43,3,
+	8,4,0,42,40,1,0,0,0,42,41,1,0,0,0,43,45,1,0,0,0,44,39,1,0,0,0,45,48,1,0,
+	0,0,46,44,1,0,0,0,46,47,1,0,0,0,47,13,1,0,0,0,48,46,1,0,0,0,5,16,23,37,
+	42,46];
+
+	private static __ATN: ATN;
+	public static get _ATN(): ATN {
+		if (!datacube_filter__parser.__ATN) {
+			datacube_filter__parser.__ATN = new ATNDeserializer().deserialize(datacube_filter__parser._serializedATN);
+		}
+
+		return datacube_filter__parser.__ATN;
+	}
+
+
+	static DecisionsToDFA = datacube_filter__parser._ATN.decisionToState.map( (ds: DecisionState, index: number) => new DFA(ds, index) );
+
+}
+
+export class FilterContext extends ParserRuleContext {
+	constructor(parser?: datacube_filter__parser, parent?: ParserRuleContext, invokingState?: number) {
+		super(parent, invokingState);
+    	this.parser = parser;
+	}
+	public EOF(): TerminalNode {
+		return this.getToken(datacube_filter__parser.EOF, 0);
+	}
+	public groupCondition(): GroupConditionContext {
+		return this.getTypedRuleContext(GroupConditionContext, 0) as GroupConditionContext;
+	}
+	public group(): GroupContext {
+		return this.getTypedRuleContext(GroupContext, 0) as GroupContext;
+	}
+    public get ruleIndex(): number {
+    	return datacube_filter__parser.RULE_filter;
+	}
+}
+
+
+export class ConditionContext extends ParserRuleContext {
+	constructor(parser?: datacube_filter__parser, parent?: ParserRuleContext, invokingState?: number) {
+		super(parent, invokingState);
+    	this.parser = parser;
+	}
+	public column(): ColumnContext {
+		return this.getTypedRuleContext(ColumnContext, 0) as ColumnContext;
+	}
+	public OPERATOR(): TerminalNode {
+		return this.getToken(datacube_filter__parser.OPERATOR, 0);
+	}
+	public IDENTIFIER(): TerminalNode {
+		return this.getToken(datacube_filter__parser.IDENTIFIER, 0);
+	}
+	public value(): ValueContext {
+		return this.getTypedRuleContext(ValueContext, 0) as ValueContext;
+	}
+    public get ruleIndex(): number {
+    	return datacube_filter__parser.RULE_condition;
+	}
+}
+
+
+export class ColumnContext extends ParserRuleContext {
+	constructor(parser?: datacube_filter__parser, parent?: ParserRuleContext, invokingState?: number) {
+		super(parent, invokingState);
+    	this.parser = parser;
+	}
+	public COLUMN(): TerminalNode {
+		return this.getToken(datacube_filter__parser.COLUMN, 0);
+	}
+    public get ruleIndex(): number {
+    	return datacube_filter__parser.RULE_column;
+	}
+}
+
+
+export class ValueContext extends ParserRuleContext {
+	constructor(parser?: datacube_filter__parser, parent?: ParserRuleContext, invokingState?: number) {
+		super(parent, invokingState);
+    	this.parser = parser;
+	}
+	public STRING(): TerminalNode {
+		return this.getToken(datacube_filter__parser.STRING, 0);
+	}
+	public NUMBER(): TerminalNode {
+		return this.getToken(datacube_filter__parser.NUMBER, 0);
+	}
+    public get ruleIndex(): number {
+    	return datacube_filter__parser.RULE_value;
+	}
+}
+
+
+export class GroupContext extends ParserRuleContext {
+	constructor(parser?: datacube_filter__parser, parent?: ParserRuleContext, invokingState?: number) {
+		super(parent, invokingState);
+    	this.parser = parser;
+	}
+	public GROUP_OPEN(): TerminalNode {
+		return this.getToken(datacube_filter__parser.GROUP_OPEN, 0);
+	}
+	public groupCondition(): GroupConditionContext {
+		return this.getTypedRuleContext(GroupConditionContext, 0) as GroupConditionContext;
+	}
+	public GROUP_CLOSE(): TerminalNode {
+		return this.getToken(datacube_filter__parser.GROUP_CLOSE, 0);
+	}
+    public get ruleIndex(): number {
+    	return datacube_filter__parser.RULE_group;
+	}
+}
+
+
+export class GroupOperatorContext extends ParserRuleContext {
+	constructor(parser?: datacube_filter__parser, parent?: ParserRuleContext, invokingState?: number) {
+		super(parent, invokingState);
+    	this.parser = parser;
+	}
+	public GROUP_OPERATOR_AND(): TerminalNode {
+		return this.getToken(datacube_filter__parser.GROUP_OPERATOR_AND, 0);
+	}
+	public GROUP_OPERATOR_OR(): TerminalNode {
+		return this.getToken(datacube_filter__parser.GROUP_OPERATOR_OR, 0);
+	}
+    public get ruleIndex(): number {
+    	return datacube_filter__parser.RULE_groupOperator;
+	}
+}
+
+
+export class GroupConditionContext extends ParserRuleContext {
+	constructor(parser?: datacube_filter__parser, parent?: ParserRuleContext, invokingState?: number) {
+		super(parent, invokingState);
+    	this.parser = parser;
+	}
+	public condition_list(): ConditionContext[] {
+		return this.getTypedRuleContexts(ConditionContext) as ConditionContext[];
+	}
+	public condition(i: number): ConditionContext {
+		return this.getTypedRuleContext(ConditionContext, i) as ConditionContext;
+	}
+	public group_list(): GroupContext[] {
+		return this.getTypedRuleContexts(GroupContext) as GroupContext[];
+	}
+	public group(i: number): GroupContext {
+		return this.getTypedRuleContext(GroupContext, i) as GroupContext;
+	}
+	public groupOperator_list(): GroupOperatorContext[] {
+		return this.getTypedRuleContexts(GroupOperatorContext) as GroupOperatorContext[];
+	}
+	public groupOperator(i: number): GroupOperatorContext {
+		return this.getTypedRuleContext(GroupOperatorContext, i) as GroupOperatorContext;
+	}
+    public get ruleIndex(): number {
+    	return datacube_filter__parser.RULE_groupCondition;
+	}
+}

package/grammar/parser/parser.ts

@@ -0,0 +1,55 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed 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 {
+  CharStreams,
+  CommonTokenStream,
+  ParseTreeVisitor,
+  ErrorListener,
+} from 'antlr4';
+import datacube_filterLexer from './generated/datacube_filter__lexer.js';
+import datacube_filterParser from './generated/datacube_filter__parser.js';
+
+class DataCubeFilterErrorListener extends ErrorListener<unknown> {
+  syntaxError(
+    recognizer: any,
+    offendingSymbol: any,
+    line: number,
+    column: number,
+    msg: string,
+    e: any,
+  ) {
+    // TODO: we should make this set the parser error state when we use this in typeahead
+    console.error(`${offendingSymbol} line ${line}, col ${column}: ${msg}`, e);
+  }
+}
+
+export function parseDataCubeQueryFilter(code: string) {
+  const charStream = CharStreams.fromString(code);
+  const lexer = new datacube_filterLexer(charStream);
+  const tokenStream = new CommonTokenStream(lexer);
+  const parser = new datacube_filterParser(tokenStream);
+  // parser.buildParseTrees = true;
+  parser.removeErrorListeners();
+  parser.addErrorListener(new DataCubeFilterErrorListener());
+  const ruleContext = parser.filter();
+  console.log(ruleContext);
+  // TODO: the last token can be used for auto-complete/typeahead
+
+  // ruleContext.children?.forEach((child) => {
+  //   console.log('suggestion', child, child.getText());
+  // });
+}

package/lib/components/Core_LegendREPLApplicationPlugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Core_LegendREPLApplicationPlugin.d.ts","sourceRoot":"","sources":["../../src/components/Core_LegendREPLApplicationPlugin.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AAExE,OAAO,EAAE,2BAA2B,EAAE,MAAM,0CAA0C,CAAC;AASvF,qBAAa,gCAAiC,SAAQ,2BAA2B;IAC/E,MAAM,CAAC,IAAI,SAAgD;;IAMlD,yBAAyB,IAAI,sBAAsB,EAAE;CAY/D"}
+{"version":3,"file":"Core_LegendREPLApplicationPlugin.d.ts","sourceRoot":"","sources":["../../src/components/Core_LegendREPLApplicationPlugin.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AAExE,OAAO,EAAE,2BAA2B,EAAE,MAAM,0CAA0C,CAAC;AAMvF,qBAAa,gCAAiC,SAAQ,2BAA2B;IAC/E,MAAM,CAAC,IAAI,SAAgD;;IAMlD,yBAAyB,IAAI,sBAAsB,EAAE;CAQ/D"}

package/lib/components/Core_LegendREPLApplicationPlugin.js

@@ -16,9 +16,6 @@
 import packageJson from '../../package.json' assert { type: 'json' };
 import { LegendREPLApplicationPlugin } from '../stores/LegendREPLApplicationPlugin.js';
 import { configureCodeEditorComponent, setupPureLanguageService, } from '@finos/legend-lego/code-editor';
-import { ModuleRegistry } from '@ag-grid-community/core';
-import { ClientSideRowModelModule } from '@ag-grid-community/client-side-row-model';
-import { RowGroupingModule } from '@ag-grid-enterprise/row-grouping';
 export class Core_LegendREPLApplicationPlugin extends LegendREPLApplicationPlugin {
     static NAME = packageJson.extensions.applicationREPLPlugin;
     constructor() {
@@ -27,10 +24,6 @@ export class Core_LegendREPLApplicationPlugin extends LegendREPLApplicationPlugi
     getExtraApplicationSetups() {
         return [
             async (applicationStore) => {
-                ModuleRegistry.registerModules([
-                    ClientSideRowModelModule,
-                    RowGroupingModule,
-                ]);
                 await configureCodeEditorComponent(applicationStore);
                 setupPureLanguageService();
             },

package/lib/components/Core_LegendREPLApplicationPlugin.js.map

@@ -1 +1 @@
-{"version":3,"file":"Core_LegendREPLApplicationPlugin.js","sourceRoot":"","sources":["../../src/components/Core_LegendREPLApplicationPlugin.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,WAAW,MAAM,oBAAoB,CAAC,SAAS,IAAI,EAAE,MAAM,EAAE,CAAC;AACrE,OAAO,EAAE,2BAA2B,EAAE,MAAM,0CAA0C,CAAC;AACvF,OAAO,EACL,4BAA4B,EAC5B,wBAAwB,GACzB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,wBAAwB,EAAE,MAAM,0CAA0C,CAAC;AACpF,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAErE,MAAM,OAAO,gCAAiC,SAAQ,2BAA2B;IAC/E,MAAM,CAAC,IAAI,GAAG,WAAW,CAAC,UAAU,CAAC,qBAAqB,CAAC;IAE3D;QACE,KAAK,CAAC,gCAAgC,CAAC,IAAI,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;IACpE,CAAC;IAEQ,yBAAyB;QAChC,OAAO;YACL,KAAK,EAAE,gBAAgB,EAAE,EAAE;gBACzB,cAAc,CAAC,eAAe,CAAC;oBAC7B,wBAAwB;oBACxB,iBAAiB;iBAClB,CAAC,CAAC;gBACH,MAAM,4BAA4B,CAAC,gBAAgB,CAAC,CAAC;gBACrD,wBAAwB,EAAE,CAAC;YAC7B,CAAC;SACF,CAAC;IACJ,CAAC"}
+{"version":3,"file":"Core_LegendREPLApplicationPlugin.js","sourceRoot":"","sources":["../../src/components/Core_LegendREPLApplicationPlugin.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,WAAW,MAAM,oBAAoB,CAAC,SAAS,IAAI,EAAE,MAAM,EAAE,CAAC;AACrE,OAAO,EAAE,2BAA2B,EAAE,MAAM,0CAA0C,CAAC;AACvF,OAAO,EACL,4BAA4B,EAC5B,wBAAwB,GACzB,MAAM,gCAAgC,CAAC;AAExC,MAAM,OAAO,gCAAiC,SAAQ,2BAA2B;IAC/E,MAAM,CAAC,IAAI,GAAG,WAAW,CAAC,UAAU,CAAC,qBAAqB,CAAC;IAE3D;QACE,KAAK,CAAC,gCAAgC,CAAC,IAAI,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;IACpE,CAAC;IAEQ,yBAAyB;QAChC,OAAO;YACL,KAAK,EAAE,gBAAgB,EAAE,EAAE;gBACzB,MAAM,4BAA4B,CAAC,gBAAgB,CAAC,CAAC;gBACrD,wBAAwB,EAAE,CAAC;YAC7B,CAAC;SACF,CAAC;IACJ,CAAC"}

package/lib/components/LegendREPLApplication.d.ts

@@ -13,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-/// <reference types="react" resolution-mode="require"/>
 export declare const LEGEND_REPL_GRID_CLIENT_ROUTE_PATTERN: Readonly<{
     DATA_CUBE: "/dataCube";
 }>;

package/lib/components/LegendREPLApplication.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LegendREPLApplication.d.ts","sourceRoot":"","sources":["../../src/components/LegendREPLApplication.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;;AAaH,eAAO,MAAM,qCAAqC;;EAEhD,CAAC;AAEH,eAAO,MAAM,gBAAgB,wBAe5B,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,KAAK,CAAC,EAAE,CAAC;IAC9C,OAAO,EAAE,MAAM,CAAC;CACjB,CAUA,CAAC"}
+{"version":3,"file":"LegendREPLApplication.d.ts","sourceRoot":"","sources":["../../src/components/LegendREPLApplication.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAaH,eAAO,MAAM,qCAAqC;;EAEhD,CAAC;AAEH,eAAO,MAAM,gBAAgB,wBAe5B,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,KAAK,CAAC,EAAE,CAAC;IAC9C,OAAO,EAAE,MAAM,CAAC;CACjB,CAUA,CAAC"}

package/lib/components/LegendREPLFrameworkProvider.d.ts

@@ -13,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-/// <reference types="react" resolution-mode="require"/>
 import { type LegendREPLApplicationStore } from '../stores/LegendREPLBaseStore.js';
 export declare const useLegendREPLApplicationStore: () => LegendREPLApplicationStore;
 export declare const LegendREPLFrameworkProvider: React.FC<{

package/lib/components/LegendREPLFrameworkProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LegendREPLFrameworkProvider.d.ts","sourceRoot":"","sources":["../../src/components/LegendREPLFrameworkProvider.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;;AAUH,OAAO,EACL,KAAK,0BAA0B,EAEhC,MAAM,kCAAkC,CAAC;AAE1C,eAAO,MAAM,6BAA6B,kCACmC,CAAC;AAoB9E,eAAO,MAAM,2BAA2B,EAAE,KAAK,CAAC,EAAE,CAAC;IACjD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B,CAIA,CAAC"}
+{"version":3,"file":"LegendREPLFrameworkProvider.d.ts","sourceRoot":"","sources":["../../src/components/LegendREPLFrameworkProvider.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAUH,OAAO,EACL,KAAK,0BAA0B,EAEhC,MAAM,kCAAkC,CAAC;AAE1C,eAAO,MAAM,6BAA6B,QAAO,0BAC4B,CAAC;AAoB9E,eAAO,MAAM,2BAA2B,EAAE,KAAK,CAAC,EAAE,CAAC;IACjD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B,CAIA,CAAC"}

package/lib/components/REPLStoreProvider.d.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { REPLStore } from '../stores/dataCube/DataCubeStore.js';
+import { REPLStore } from '../stores/dataCube/REPLStore.js';
 export declare const REPLStoreProvider: ({ children, }: {
     children: React.ReactNode;
 }) => React.ReactElement;

package/lib/components/REPLStoreProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"REPLStoreProvider.d.ts","sourceRoot":"","sources":["../../src/components/REPLStoreProvider.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,OAAO,EAAE,SAAS,EAAE,MAAM,qCAAqC,CAAC;AAQhE,eAAO,MAAM,iBAAiB,kBAE3B;IACD,QAAQ,EAAE,MAAM,SAAS,CAAC;CAC3B,KAAG,MAAM,YAWT,CAAC;AAEF,eAAO,MAAM,YAAY,QAAO,SAI7B,CAAC;AAEJ,eAAO,MAAM,aAAa,qBAAsB,MAAM,EAAE,KAAG,MAAM,EAO9D,CAAC"}
+{"version":3,"file":"REPLStoreProvider.d.ts","sourceRoot":"","sources":["../../src/components/REPLStoreProvider.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,OAAO,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAQ5D,eAAO,MAAM,iBAAiB,kBAE3B;IACD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B,KAAG,KAAK,CAAC,YAWT,CAAC;AAEF,eAAO,MAAM,YAAY,QAAO,SAI7B,CAAC;AAEJ,eAAO,MAAM,aAAa,qBAAsB,KAAK,CAAC,EAAE,KAAG,KAAK,CAAC,EAO9D,CAAC"}

package/lib/components/REPLStoreProvider.js

@@ -16,7 +16,7 @@ import { jsx as _jsx } from "react/jsx-runtime";
  */
 import { createContext, useContext } from 'react';
 import { useLocalObservable } from 'mobx-react-lite';
-import { REPLStore } from '../stores/dataCube/DataCubeStore.js';
+import { REPLStore } from '../stores/dataCube/REPLStore.js';
 import { guaranteeNonNullable } from '@finos/legend-shared';
 import { useApplicationStore } from '@finos/legend-application';
 const REPLStoreContext = createContext(undefined);

package/lib/components/REPLStoreProvider.js.map

@@ -1 +1 @@
-{"version":3,"file":"REPLStoreProvider.js","sourceRoot":"","sources":["../../src/components/REPLStoreProvider.tsx"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AAClD,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,SAAS,EAAE,MAAM,qCAAqC,CAAC;AAChE,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAIhE,MAAM,gBAAgB,GAAG,aAAa,CAAwB,SAAS,CAAC,CAAC;AAEzE,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,EAChC,QAAQ,GAGT,EAAsB,EAAE;IACvB,MAAM,gBAAgB,GAAG,mBAAmB,EAGzC,CAAC;IACJ,MAAM,KAAK,GAAG,kBAAkB,CAAC,GAAG,EAAE,CAAC,IAAI,SAAS,CAAC,gBAAgB,CAAC,CAAC,CAAC;IACxE,OAAO,CACL,KAAC,gBAAgB,CAAC,QAAQ,IAAC,KAAK,EAAE,KAAK,YACpC,QAAQ,GACiB,CAC7B,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,YAAY,GAAG,GAAc,EAAE,CAC1C,oBAAoB,CAClB,UAAU,CAAC,gBAAgB,CAAC,EAC5B,kCAAkC,CACnC,CAAC;AAEJ,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,gBAA0B,EAAY,EAAE,CACpE,SAAS,aAAa;IACpB,OAAO,CACL,KAAC,iBAAiB,cAChB,KAAC,gBAAgB,KAAG,GACF,CACrB,CAAC;AACJ,CAAC,CAAC"}
+{"version":3,"file":"REPLStoreProvider.js","sourceRoot":"","sources":["../../src/components/REPLStoreProvider.tsx"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AAClD,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAC5D,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAIhE,MAAM,gBAAgB,GAAG,aAAa,CAAwB,SAAS,CAAC,CAAC;AAEzE,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,EAChC,QAAQ,GAGT,EAAsB,EAAE;IACvB,MAAM,gBAAgB,GAAG,mBAAmB,EAGzC,CAAC;IACJ,MAAM,KAAK,GAAG,kBAAkB,CAAC,GAAG,EAAE,CAAC,IAAI,SAAS,CAAC,gBAAgB,CAAC,CAAC,CAAC;IACxE,OAAO,CACL,KAAC,gBAAgB,CAAC,QAAQ,IAAC,KAAK,EAAE,KAAK,YACpC,QAAQ,GACiB,CAC7B,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,YAAY,GAAG,GAAc,EAAE,CAC1C,oBAAoB,CAClB,UAAU,CAAC,gBAAgB,CAAC,EAC5B,kCAAkC,CACnC,CAAC;AAEJ,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,gBAA0B,EAAY,EAAE,CACpE,SAAS,aAAa;IACpB,OAAO,CACL,KAAC,iBAAiB,cAChB,KAAC,gBAAgB,KAAG,GACF,CACrB,CAAC;AACJ,CAAC,CAAC"}

package/lib/components/dataCube/DataCube.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DataCube.d.ts","sourceRoot":"","sources":["../../../src/components/dataCube/DataCube.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AASH,eAAO,MAAM,QAAQ;;CAuCnB,CAAC"}
+{"version":3,"file":"DataCube.d.ts","sourceRoot":"","sources":["../../../src/components/dataCube/DataCube.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AA+CH,eAAO,MAAM,QAAQ;;CAuBnB,CAAC"}