@arcgis/coding-components 4.31.0-next.2 → 4.31.0-next.21

package/dist/types/utils/sql-expr-monaco/sql-expr-completion.d.ts

@@ -0,0 +1,6 @@
+import * as monaco from "monaco-editor";
+import type { ApiItem, ApiVariable } from "@arcgis/languages-api-utils";
+export declare function sqlExpressionCompletion(range: monaco.IRange, model: monaco.editor.ITextModel, position: monaco.Position, sdkFunctions: Record<string, ApiItem>): monaco.languages.CompletionItem[];
+/** source  */
+export declare const sqlBinOps: string[];
+export declare function generateCompletionItems(fields: ApiVariable[], range: monaco.IRange, sdkFunctions: Record<string, ApiItem>): Record<"fieldsCompletion" | "sqlBinOpsCompletion" | "sqlDataTypeCompletion" | "sqlFunctionCompletion" | "sqlKeywordsCompletion", monaco.languages.CompletionItem[]>;

package/dist/types/utils/sql-expr-monaco/sql-expr-constants.d.ts

@@ -0,0 +1,45 @@
+import type { MarkerSeverity } from "monaco-editor";
+export declare enum ChildBearingProperties {
+    ARGS = "args",
+    CLAUSES = "clauses",
+    ELSE = "else",
+    END = "end",
+    EXPR = "expr",
+    LEFT = "left",
+    OPERAND = "operand",
+    QUALIFIER = "qualifier",
+    RIGHT = "right",
+    START = "start",
+    VALUE = "value"
+}
+export declare enum ChildBearingNodeTypes {
+    CASE_EXPRESSION = "case-expression",
+    EXPRESSION_LIST = "expression-list",
+    FUNCTION = "function",
+    INTERVAL = "interval",
+    INTERVAL_QUALIFIER = "interval-qualifier",
+    WHEN_CLAUSE = "when-clause",
+    UNARY_EXPRESSION = "unary-expression",
+    BINARY_EXPRESSION = "binary-expression"
+}
+export declare const CHILD_BEARING_PROPERTIES: {
+    readonly "case-expression": readonly [ChildBearingProperties.CLAUSES, ChildBearingProperties.OPERAND, ChildBearingProperties.ELSE];
+    readonly "when-clause": readonly [ChildBearingProperties.OPERAND, ChildBearingProperties.VALUE];
+    readonly "expression-list": readonly [ChildBearingProperties.VALUE];
+    readonly "unary-expression": readonly [ChildBearingProperties.EXPR];
+    readonly "binary-expression": readonly [ChildBearingProperties.LEFT, ChildBearingProperties.RIGHT];
+    readonly function: readonly [ChildBearingProperties.ARGS];
+    readonly interval: readonly [ChildBearingProperties.VALUE, ChildBearingProperties.QUALIFIER];
+    readonly "interval-qualifier": readonly [ChildBearingProperties.START, ChildBearingProperties.END];
+};
+export declare const sqlFunctionParamKeywords: {
+    CAST: string[];
+    EXTRACT: string[];
+    TRIM: string[];
+};
+export declare const MarkerType: {
+    Hint: MarkerSeverity.Hint;
+    Info: MarkerSeverity.Info;
+    Warning: MarkerSeverity.Warning;
+    Error: MarkerSeverity.Error;
+};

package/dist/types/utils/sql-expr-monaco/sql-expr-contribution.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/utils/sql-expr-monaco/sql-expr-defaults.d.ts

@@ -0,0 +1,21 @@
+import type FeatureLayer from "@arcgis/core/layers/FeatureLayer";
+import type { IEditorProfileDefinition, IPredefinedProfile } from "../profile/types";
+import { Uri } from "monaco-editor";
+import { LanguageDefaultsBase } from "../language-defaults-base";
+import type { ApiCategory } from "@arcgis/languages-api-utils";
+declare class SqlExprDefaults extends LanguageDefaultsBase {
+    protected _languageId: string;
+    protected _languageOptions: {};
+    private _layerMap;
+    updateFeatureLayerForModel(modelId: Uri | string, layer: FeatureLayer): void;
+    setLanguageOptions(languageOptions: {
+        assetsPath?: string | undefined;
+    }): void;
+    getFeatureLayerForModel(modelId: Uri | string): FeatureLayer | undefined;
+    setProfileForModel(modelId: Uri | string, definition: IEditorProfileDefinition | IPredefinedProfile | undefined, apiContext?: {
+        locale: string;
+    }): Promise<void>;
+    getApiLibrary(modelId: string): Promise<ApiCategory[]>;
+}
+export type { SqlExprDefaults };
+export declare const sqlExprDefaults: SqlExprDefaults;

package/dist/types/utils/sql-expr-monaco/sql-expr-language-features.d.ts

@@ -0,0 +1,39 @@
+import { editor } from "monaco-editor";
+import type { IRange, Position, languages } from "monaco-editor";
+import type { SqlExprDefaults } from "./sql-expr-defaults";
+import type { ISqlExprWorkerAccessor } from "./types";
+import type { SqlExprDiagnosticService } from "./sql-expr-mode";
+export declare class SqlExprCompletionProvider implements languages.CompletionItemProvider {
+    private _defaults;
+    private _sdkFunctions;
+    constructor(_defaults: SqlExprDefaults);
+    provideCompletionItems(model: editor.ITextModel, position: Position): Promise<languages.CompletionList | undefined>;
+}
+export declare class SqlExprDiagnosticsAdapter {
+    private _languageId;
+    private _worker;
+    private _disposables;
+    private _listener;
+    private _diagnosticsService;
+    private _defaults;
+    constructor(_languageId: string, _worker: ISqlExprWorkerAccessor, { defaults, diagnosticService, }: {
+        defaults: SqlExprDefaults;
+        diagnosticService: SqlExprDiagnosticService;
+    });
+    private _doValidate;
+}
+export declare const sqlParenLessFunctions: string[];
+export declare const dataTypes: string[];
+export declare const getKeywords: (identifier: string) => string[] | undefined;
+export declare const getDelimiterPosition: (index: number, node: any, model: editor.ITextModel, lastIndex: number) => IRange;
+export declare const isSqlParenLessFunction: (word: string) => boolean;
+export declare const getCursorWithinRange: (position: Position, startPos: IRange, endPos: IRange) => boolean[];
+export declare const generateTypeDescription: (name: string, parameters: {
+    description: string;
+    name: string;
+    type: string[] | string;
+}[], returnType: string[] | string) => string;
+export declare const generateCompletionDocumentation: (description: string, examples: {
+    code: string;
+    description: string;
+}[]) => string;

package/dist/types/utils/sql-expr-monaco/sql-expr-language-syntax.d.ts

@@ -0,0 +1,8 @@
+import * as monaco from "monaco-editor";
+/**
+ * This file is mostly ported from https://github.com/microsoft/monaco-editor/blob/main/src/basic-languages/sql/sql.ts
+ */
+import IMonarchLanguage = monaco.languages.IMonarchLanguage;
+import LanguageConfiguration = monaco.languages.LanguageConfiguration;
+export declare const sqlExprLanguageConfig: LanguageConfiguration;
+export declare const sqlExprLanguageSyntax: IMonarchLanguage;

package/dist/types/utils/sql-expr-monaco/sql-expr-mode.d.ts

@@ -0,0 +1,43 @@
+import type { IEvent, Uri, editor } from "monaco-editor";
+import type { ISqlExprWorker } from "./types";
+import { type SqlExprDefaults } from "./sql-expr-defaults";
+/**
+ * Returns the sql-expression worker for the model uris.
+ * @param uris The model uris for which to get the worker.
+ * @returns The sql-expression worker.
+ */
+export declare function getSqlExprWorker(...uris: Uri[]): Promise<ISqlExprWorker>;
+export interface ISqlExprDiagnosticEvent {
+    /**
+     * The uri of the model for which the diagnostics changed.
+     */
+    uri: Uri;
+    /**
+     * The diagnostics for the model.
+     */
+    diagnostics: editor.IMarkerData[];
+}
+export interface ISqlExprDiagnosticService {
+    onDiagnosticsChange: IEvent<ISqlExprDiagnosticEvent>;
+}
+declare class SqlExprDiagnosticService implements ISqlExprDiagnosticService {
+    private _onDiagnosticsChange;
+    /**
+     * An event to signal changes to the diagnostics.
+     * The event value is the uri string and the diagnostics.
+     */
+    get onDiagnosticsChange(): IEvent<ISqlExprDiagnosticEvent>;
+    /**
+     * Fires the diagnostics change event.
+     * @param uri The uri of the model for which the diagnostics changed.
+     * @param diagnostics The diagnostics for the model.
+     */
+    fireDiagnosticsChange(uri: Uri, diagnostics: editor.IMarkerData[]): void;
+}
+export type { SqlExprDiagnosticService };
+/**
+ *
+ * @returns The Sql Expression Diagnostic Service.
+ */
+export declare function getSqlExprDiagnosticService(): ISqlExprDiagnosticService;
+export declare function setupMode(defaults: SqlExprDefaults): void;

package/dist/types/utils/sql-expr-monaco/sql-expr-service-accessors.d.ts

@@ -0,0 +1,19 @@
+import type * as sqlExprModeModule from "./sql-expr-mode";
+import type { ISqlExprWorker } from "./types";
+import type { Uri } from "monaco-editor";
+type SqlExprModeType = typeof sqlExprModeModule;
+/**
+ * Returns the sql-expression worker for the model.
+ * Example:
+ * ```ts
+ * const sqlExpressionWorker = await getSqlExpressionWorker(model.uri);
+ * ```
+ * @returns sql-expression worker
+ */
+export declare function getSqlExprWorker(uri: Uri): Promise<ISqlExprWorker>;
+/**
+ * Request the sql-expression mode
+ * @returns sql-expression mode module
+ */
+export declare function getMode(): Promise<SqlExprModeType>;
+export {};

package/dist/types/utils/sql-expr-monaco/sql-expr-validation-diagnostic-adapter.d.ts

@@ -0,0 +1,34 @@
+export declare enum ValidationDiagnosticCodes {
+    ExpectedDateTimeValue = "ExpectedDateTimeValue",
+    ExpectedNumericalLiteral = "ExpectedNumericalLiteral",
+    ExpectedToken = "ExpectedToken",
+    FunctionNotSupported = "FunctionNotSupported",
+    IncompatibleListDataType = "IncompatibleListDataType",
+    IncorrectArgumentLength = "IncorrectArgumentLength",
+    IncorrectCastParameters = "IncorrectCastParameters",
+    IncorrectExtractParameters = "IncorrectExtractParameters",
+    IncorrectSubstringParameters = "IncorrectSubstringParameters",
+    IncorrectTrimParameters = "IncorrectTrimParameters",
+    InvalidElseClause = "InvalidElseClause",
+    InvalidThenClause = "InvalidThenClause",
+    InvalidEndOnWhen = "InvalidEndOnWhen",
+    InvalidTrimCharacter = "InvalidTrimCharacter",
+    MismatchedTypes = "MismatchedTypes",
+    MissingValueInCaseClause = "MissingValueInCaseClause",
+    NotCallable = "NotCallable",
+    TypeNotAssignable = "TypeNotAssignable",
+    UnexpectedEnd = "UnexpectedEnd.",
+    UnexpectedIdentifier = "UnexpectedIdentifier",
+    UnexpectedNumber = "UnexpectedNumber",
+    UnexpectedTextLiteral = "UnexpectedTextLiteral",
+    UnexpectedToken = "UnexpectedToken",
+    UnknownField = "UnknownField",
+    UnsupportedOperator = "UnsupportedOperator",
+    UnsupportedSyntax = "UnsupportedSyntax",
+    InvalidIntervalQualifier = "InvalidIntervalQualifier",
+    EmptyCaseExpression = "EmptyCaseExpression"
+}
+export declare const DiagnosticMessages: {
+    [key in ValidationDiagnosticCodes]: string;
+};
+export declare const getDiagnosticMessage: (diagnosticCode: ValidationDiagnosticCodes, replacements?: Record<string, number | string>) => string;

package/dist/types/utils/sql-expr-monaco/sql-expr-validation-utils.d.ts

@@ -0,0 +1,100 @@
+import type { IRange, editor } from "monaco-editor";
+import type { SQLNode } from "./DependentFiles/WhereGrammar";
+import type { ArcGISFieldType, PeggyError, SqlExpressionLiteral, PeggyLocation } from "./types";
+import type { ApiVariable } from "@arcgis/languages-api-utils";
+export interface ValidationSyntaxContext {
+    token: string;
+    range: IRange;
+    startDelimiter?: boolean;
+    content?: ValidationSyntaxContext[];
+}
+export declare enum TokenType {
+    Single = "SINGLE",
+    EmptyField = "EMPTY_FIELD",
+    Error = "ERROR",
+    Field = "FIELD",
+    KeywordIn = "IN",
+    KeywordNotIn = "NOT IN",
+    KeywordBetween = "BETWEEN",
+    KeywordNotBetween = "NOT BETWEEN",
+    List = "LIST",
+    Negation = "NOT",
+    Number = "NUMBER",
+    Operator = "OPERATOR",
+    Parentheses = "PARENTHESES",
+    String = "STRING",
+    Unknown = "UNKNOWN"
+}
+export declare enum Token {
+    Case = "CASE",
+    CaseElse = "ELSE",
+    CaseThen = "THEN",
+    CaseWhen = "WHEN",
+    Comma = ",",
+    DoubleQuote = "\"",
+    Empty = "",
+    End = "END",
+    Interval = "INTERVAL",
+    LeftParentheses = "(",
+    NewLine = "\n",
+    RightParentheses = ")",
+    SingleQuote = "'",
+    WhiteSpace = " "
+}
+export declare enum BinaryOperator {
+    And = "AND",
+    Or = "OR",
+    Is = "IS",
+    IsNot = "ISNOT",
+    In = "IN",
+    NotIn = "NOT IN",
+    Between = "BETWEEN",
+    NotBetween = "NOTBETWEEN",
+    Like = "LIKE",
+    NotLike = "NOT LIKE",
+    NotEquals = "<>",
+    LessThan = "<",
+    GreaterThan = ">",
+    GreaterThanEqual = ">=",
+    LessThanEqual = "<=",
+    Equal = "=",
+    Multiply = "*",
+    Subtract = "-",
+    Add = "+",
+    Divide = "/",
+    Concatenate = "||"
+}
+export declare enum NodeReturnType {
+    Boolean = "BOOLEAN",
+    Double = "DOUBLE",
+    ExpressionList = "EXPRESSION-LIST",
+    Float = "FLOAT",
+    Integer = "INTEGER",
+    Null = "NULL",
+    Number = "NUMBER",
+    Real = "REAL",
+    String = "STRING",
+    SmallInt = "SMALLINT",
+    UnknownFunction = "UNKNOWN_FUNCTION"
+}
+export declare enum CallableExpressionResponse {
+    Function = "FUNCTION",
+    ExpressionList = "EXPRESSION_LIST",
+    Success = "SUCCESS",
+    NonCallable = "NON_CALLABLE"
+}
+export declare const tokenizationRegex: RegExp;
+export declare const isValidIntervalValue: RegExp;
+export declare const validOps: string[];
+export declare const relationalTypes: SqlExpressionLiteral[];
+export declare const qualifiers: TokenType[];
+export declare function convertArcgisTypeToSqlReturnType(arcgisType: ArcGISFieldType): SqlExpressionLiteral;
+export declare const identifyNodeReturnType: (node: SQLNode, fields: ApiVariable[]) => SqlExpressionLiteral | "time-only" | "unknown_function";
+export declare const isNumericType: (type: SqlExpressionLiteral) => boolean;
+export declare const formatListToString: (types: SqlExpressionLiteral[], delimiter: string) => string;
+export declare const formatType: (type: string) => string;
+export declare const getValueFromNode: (node: SQLNode) => number | string;
+export declare const addNewMarker: (message: string, range: IRange | PeggyLocation, markers: editor.IMarkerData[], isNodeFormat?: boolean) => void;
+export declare const validateTypeMatch: (node: SQLNode, expectedType: NodeReturnType, markers: editor.IMarkerData[], fields: ApiVariable[]) => void;
+export declare function isSyntaxError(error: PeggyError): boolean;
+export declare function formatSyntaxError(error: PeggyError): string;

package/dist/types/utils/sql-expr-monaco/sql-expr-validation.d.ts

@@ -0,0 +1,41 @@
+import type { SQLNode } from "./DependentFiles/WhereGrammar";
+import type { editor } from "monaco-editor";
+import type { ApiCategory, ApiContext } from "@arcgis/languages-api-utils";
+export declare class SQLExpressionValidation {
+    private callStack;
+    private _sdkFunctions;
+    private _fields;
+    markers: editor.IMarkerData[];
+    constructor(sdkLibrary: ApiCategory[], _apiContext: ApiContext);
+    /**
+     * validates the SQL Expression by generating an AST and traversing it
+     * @param modelContent The SQL Expression to validate
+     */
+    validateModel(modelContent: string): void;
+    /**
+     * a DFS traversal of the SQL Expression AST
+     * @param node The node to traverse, start with the root node
+     */
+    traverse(node: SQLNode): void;
+    /**
+     * Validates a nodes syntax and types
+     * @param node The node to validate
+     */
+    private _validateNode;
+    private _handleParserFailure;
+    /**
+     * Formats a node's range into a Monaco IRange object.
+     * @param node
+     */
+    private _getRange;
+    /**
+     * finds the function in the SDK library.
+     * @param name name of the function
+     */
+    private _getFunction;
+    /**
+     * looks at the node and finds any children attached to it. If there are children, it will traverse them.
+     * @param node The current node to traverse
+     */
+    private _traverseChildren;
+}

package/dist/types/utils/sql-expr-monaco/sql-expr-worker-manager.d.ts

@@ -0,0 +1,17 @@
+import type { Uri } from "monaco-editor";
+import type { ISqlExprWorker } from "./types";
+import type { SqlExprDefaults } from "./sql-expr-defaults";
+/**
+ * Manager to create our sql-expression worker and client proxy
+ */
+export declare class SqlExprWorkerManager {
+    private _defaults;
+    private _worker;
+    private _client;
+    private _configChangeListener;
+    constructor(_defaults: SqlExprDefaults);
+    dispose(): void;
+    stopWorker(): void;
+    private _getClientProxy;
+    getLanguageServiceWorker(...resources: Uri[]): Promise<ISqlExprWorker>;
+}

package/dist/types/utils/sql-expr-monaco/sql-expr.worker.d.ts

@@ -0,0 +1,24 @@
+import type { languages, worker, editor } from "monaco-editor";
+import type { ISqlExprWorker } from "./types";
+import type { ApiCategory, ApiContext } from "@arcgis/languages-api-utils";
+interface IWorkerData {
+    languageId: string;
+    languageOptions?: {
+        assetsPath?: string;
+    };
+}
+/**
+ * The ArcGIS SQL Expression Web Worker is leveraging the Arcade Language Service to provide the editor functionalities.
+ * The ArcGIS SQL Expression Web Worker is proxied by the Monaco worker server.
+ */
+export declare class SqlExprWorker implements ISqlExprWorker {
+    private _ctx;
+    private _languageId;
+    private _apiService;
+    constructor(_ctx: worker.IWorkerContext, { languageId, languageOptions }: IWorkerData);
+    doValidation(modelId: string, context: ApiContext): Promise<editor.IMarkerData[]>;
+    doComplete(modelId: string): Promise<languages.CompletionList>;
+    getApiLibrary(context: ApiContext): Promise<ApiCategory[]>;
+    private _getTextDocument;
+}
+export {};

package/dist/types/utils/sql-expr-monaco/sql-expression-profile-strategy.d.ts

@@ -0,0 +1,13 @@
+import type { EditorProfile } from "../profile/editor-profile";
+import type { ApiProfile, ApiVariable } from "@arcgis/languages-api-utils";
+import type { IPredefinedProfile, IEditorProfileDefinition } from "../profile/types";
+/**
+ * Converts an editor profile to an api profile.
+ * The api profile is an optimized version of the editor profile designed for minimal data transfer between the main thread and the worker.
+ */
+export declare const sqlExprEditorToApiProfile: (editorProfile: EditorProfile) => ApiProfile;
+export declare function convertToEditorProfileDefinition(predefinedProfile: IPredefinedProfile, locale?: string): Promise<IEditorProfileDefinition | undefined>;
+/**
+ * util to retrieve fields from the $layer variable in the api context.
+ */
+export declare const getFieldsFromLayerVariable: (profile: ApiProfile) => ApiVariable[];

package/dist/types/utils/sql-expr-monaco/types.d.ts

@@ -0,0 +1,89 @@
+import type { Thenable, Uri, languages, editor } from "monaco-editor";
+import type { Position } from "vscode-languageserver-types";
+import type { PeggySyntaxError, FileRange } from "./PeggyGrammar/sql92grammar";
+import type { DataTypeNode, SQLNode } from "./DependentFiles/WhereGrammar";
+import type { ApiCategory, ApiContext } from "@arcgis/languages-api-utils";
+export interface ISqlExprWorker {
+    doValidation: (modelId: string, context: ApiContext) => Thenable<editor.IMarkerData[]>;
+    doComplete: (modelId: string, position: Position) => Thenable<languages.CompletionList>;
+    getApiLibrary: (context: ApiContext) => Thenable<ApiCategory[]>;
+}
+export type ISqlExprWorkerAccessor = (...more: Uri[]) => Thenable<ISqlExprWorker>;
+export interface ApiContextType {
+    description: string;
+    parameters: {
+        name: string;
+        type: string[] | string;
+        description: string;
+    }[];
+    returnValue: string[] | string;
+    examples: {
+        code: string;
+        description: string;
+    }[];
+    snippet: string[] | string;
+    name: string;
+    bundle: string;
+}
+/**
+ * SQL Expression Literal. These are the types that occur within nodes of the AST generated by the peggy parser.
+ **/
+export type SqlExpressionLiteral = 
+/**
+ * "date"
+ * "float"
+ * "integer"
+ * "real"
+ * "smallint"
+ * "time"
+ * "timestamp"
+ * "varchar"
+ */
+DataTypeNode["value"]["type"]
+/**
+ * "case-expression"
+ * "when-clause"
+ * "parameter"
+ * "expression-list"
+ * "unary-expression"
+ * "binary-expression"
+ * "null"
+ * "boolean"
+ * "string"
+ * "number"
+ * "date"
+ * "time"
+ * "timestamp"
+ * "column-reference"
+ * "current-time"
+ * "interval"
+ * "interval-qualifier"
+ * "interval-period"
+ * "function"
+ * "data-type"
+ */
+ | SQLNode["type"];
+export type ArcGISFieldType = 
+/**
+ * "string"
+ * "date"
+ * "integer"
+ * "small-integer"
+ * "big-integer"
+ * "single"
+ * "double"
+ * "long"
+ * "date-only"
+ * "time-only"
+ * "timestamp-offset"
+ * "oid"
+ * "geometry"
+ * "blob"
+ * "raster"
+ * "guid"
+ * "global-id"
+ * "xml"
+ */
+__esri.Field["type"];
+export type PeggyError = PeggySyntaxError;
+export type PeggyLocation = FileRange;

package/package.json

@@ -1,11 +1,7 @@
 {
   "name": "@arcgis/coding-components",
+  "version": "4.31.0-next.21",
   "description": "Contains components for editing code in different languages. The currently supported languages are html, css, json, TypeScript, JavaScript, and Arcade.",
-  "homepage": "https://developers.arcgis.com/javascript/latest/",
-  "version": "4.31.0-next.2",
-  "module": "dist/components/index.js",
-  "main": "dist/index.cjs.js",
-  "types": "dist/types/index.d.ts",
   "keywords": [
     "ArcGIS",
     "javascript",
@@ -17,6 +13,10 @@
     "web-components",
     "Esri"
   ],
+  "homepage": "https://developers.arcgis.com/javascript/latest/",
+  "main": "dist/index.cjs.js",
+  "module": "dist/components/index.js",
+  "types": "dist/types/index.d.ts",
   "files": [
     "dist/"
   ],
@@ -37,65 +37,71 @@
     "build:components": "stencil build",
     "build:components:dev": "stencil build --dev",
     "build:monaco-workers": "tsx ./scripts/build-monaco-workers.ts",
+    "build:peggy": "peggy --plugin ../../../node_modules/ts-pegjs/dist/tspegjs -o ./src/utils/sql-expr-monaco/PeggyGrammar/sql92grammar.ts ./src/utils/sql-expr-monaco/PeggyGrammar/sql92grammar.peggy",
     "test": "stencil test --spec --no-build",
     "test:e2e": "stencil test --e2e",
     "test:spec": "stencil test --spec",
     "test.watch": "stencil test --spec --e2e --watchAll",
     "clean": "rimraf ./node_modules ./storybook-static ./storybook-static-external ./turbo ./dist ./www",
-    "pre": "rimraf ./dist ./www && yarn awc build-t9n-types && yarn build:monaco-workers",
+    "pre": "rimraf ./dist ./www && yarn build:monaco-workers",
     "pre:dev": "yarn pre --sourcemap && yarn awc create-mock-doc",
     "update:storybook": "npx storybook@latest upgrade",
     "generate": "stencil generate"
   },
   "dependencies": {
-    "@arcgis/arcade-languageservice": "4.31.0-next.2",
-    "@arcgis/components-controllers": "4.31.0-next.2",
-    "@arcgis/components-utils": "4.31.0-next.2",
+    "@arcgis/arcade-languageservice": "4.31.0-next.21",
+    "@arcgis/components-controllers": "4.31.0-next.21",
+    "@arcgis/components-utils": "4.31.0-next.21",
+    "@arcgis/languages-api-utils": "4.31.0-next.21",
     "@stencil/core": "4.17.1",
     "monaco-editor": "0.45.0",
     "vscode-languageserver-types": "^3.17.5"
   },
   "devDependencies": {
-    "@arcgis/components-plugins": "4.31.0-next.2",
-    "@arcgis/core": ">=4.30.0-next <4.31",
-    "@arcgis/core-adapter": "4.31.0-next.2",
-    "@arcgis/storybook-utils": "4.31.0-next.2",
-    "@arcgis/typescript-config": "4.31.0-next.2",
+    "@arcgis/components-build-utils": "4.31.0-next.21",
+    "@arcgis/components-plugins": "4.31.0-next.21",
+    "@arcgis/core": ">=4.31.0-next <4.32",
+    "@arcgis/core-adapter": "4.31.0-next.21",
+    "@arcgis/storybook-utils": "4.31.0-next.21",
+    "@arcgis/typescript-config": "4.31.0-next.21",
     "@esri/calcite-components": "^2.8.0",
     "@stencil/angular-output-target": "0.8.4",
     "@stencil/react-output-target": "0.5.3",
     "@stencil/sass": "^3.0.0",
     "@types/estree": "^1.0.0",
     "@types/jest": "^29.5.0",
+    "@types/luxon": "^3",
     "@types/marked": "^5.0.2",
     "@types/node": "^20.2.5",
     "@types/postcss-url": "^10.0.0",
     "@types/resize-observer-browser": "^0.1.7",
     "chromatic": "^11.3.0",
-    "esbuild": "^0.20.2",
+    "esbuild": "^0.21.4",
     "eslint": "^8.55.0",
     "jest": "^29.5.0",
     "jest-cli": "^29.5.0",
-    "magic-string": "^0.30.0",
+    "magic-string": "^0.30.10",
     "marked": "^5.1.2",
+    "peggy": "3.0.2",
     "postcss": ">=8.4.31",
     "postcss-discard-comments": "^5.1.2",
     "postcss-url": "^10.1.3",
     "puppeteer": "^21.9.0",
     "resolve-pkg": "^2.0.0",
     "rimraf": "^5.0.0",
-    "rollup": "^3.25.0",
+    "rollup": "^4.13.0",
     "rollup-plugin-import-css": "^3.1.0",
     "rollup-plugin-node-polyfills": "^0.2.1",
-    "storybook": "^8.0.5",
+    "storybook": "^8.1.10",
+    "ts-pegjs": "^4.2.1",
     "tsx": "^4.7.0",
-    "typescript": "~5.3.0",
+    "typescript": "~5.4.0",
     "vscode-languageserver-textdocument": "^1.0.11",
     "yargs": "^17.1.1"
   },
   "peerDependencies": {
-    "@arcgis/core": ">=4.30.0-next <4.31",
+    "@arcgis/core": ">=4.31.0-next <4.32",
     "@esri/calcite-components": "^2.8.0"
   },
-  "gitHead": "61eee9bc3c28efbda9ecca86026becdf521ee81d"
+  "gitHead": "c366e874dab93d7398c3dd548a3afa9c19301e22"
 }