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

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

@@ -0,0 +1,41 @@
+import type { SqlTimeStampOffset } from "./SqlTimestampOffset";
+import { ArcadeDate } from "./support";
+import type { Zone } from "luxon";
+import { DateTime } from "luxon";
+export declare function standardiseDateOnlyFormat(format: string): string;
+export declare class DateOnly {
+    protected _year: number;
+    protected _month: number;
+    protected _day: number;
+    private constructor();
+    readonly declaredRootClass: string;
+    get month(): number;
+    get monthJS(): number;
+    get year(): number;
+    get day(): number;
+    get isValid(): boolean;
+    equals(v: any): boolean;
+    clone(): DateOnly;
+    toDateTime(timeZone: Zone | string): DateTime;
+    toDateTimeLuxon(timeZone: Zone | string): DateTime;
+    toString(): string;
+    toFormat(format?: string | null): string;
+    toArcadeDate(): ArcadeDate;
+    toNumber(): number;
+    toJSDate(): Date;
+    toStorageFormat(): string;
+    toSQLValue(): string;
+    toSQLWithKeyword(): string;
+    plus(format: string, amount: number): DateOnly | null;
+    toUTCDateTime(): DateTime;
+    difference(dateonly: DateOnly, format: string): number;
+    static fromMilliseconds(ms: number): DateOnly | null;
+    static fromSeconds(seconds: number): DateOnly | null;
+    static fromReader(v: string | null): DateOnly | null;
+    static fromParts(year: number, month: number, day: number): DateOnly | null;
+    static fromDateJS(date: Date): DateOnly;
+    static fromDateTime(date: DateTime): DateOnly;
+    static fromSqlTimeStampOffset(date: SqlTimeStampOffset): DateOnly;
+    static fromString(datestring: string, format?: string | null): DateOnly | null;
+    static fromNow(timeReferenceZone?: string): DateOnly;
+}

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

@@ -0,0 +1,16 @@
+import type { IntervalPeriodNode, IntervalQualifierNode } from "./support";
+export declare class SqlInterval {
+    private static _fixDefaults;
+    static _parseSecondsComponent(destination: SqlInterval, seconds: string): void;
+    static createFromMilliseconds(vo: number): SqlInterval;
+    static createFromValueAndQualifer(value: string, qualifier: IntervalPeriodNode | IntervalQualifierNode, op: "-" | "" | "+"): SqlInterval;
+    op: "-" | "+";
+    day: number;
+    second: number;
+    hour: number;
+    month: number;
+    year: number;
+    minute: number;
+    millis: number;
+    valueInMilliseconds(): number;
+}

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

@@ -0,0 +1,26 @@
+import { DateTime } from "luxon";
+export declare class SqlTimeStampOffset {
+    private _timeStampOffset;
+    constructor(_timeStampOffset: string);
+    private _date;
+    toDateTime(): DateTime;
+    get isValid(): boolean;
+    get timezoneOffsetHour(): number;
+    get timezoneOffsetMinutes(): number;
+    toMilliseconds(): number;
+    get hour(): number;
+    get minute(): number;
+    get second(): number;
+    get day(): number;
+    get month(): number;
+    get year(): number;
+    startOfDay(): SqlTimeStampOffset;
+    static fromJSDate(value: Date): SqlTimeStampOffset;
+    static fromDateTime(value: DateTime): SqlTimeStampOffset;
+    static fromParts(year: number, month: number, day?: number, hour?: number, minute?: number, second?: number, millisecond?: number, negativeOffset?: boolean, offseth?: number, offsetm?: number): SqlTimeStampOffset;
+    toStorageFormat(): string;
+    toString(): string;
+    toSQLValue(): string;
+    toSQLWithKeyword(): string;
+    addMilliseconds(mills: number): SqlTimeStampOffset;
+}

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

@@ -0,0 +1,37 @@
+import type { SqlTimeStampOffset } from "./SqlTimestampOffset";
+import { DateTime } from "luxon";
+export declare function standardiseTimeFormat(format: string | null): string;
+/**
+ * TimeOnly: Arcade type for defining a Time value
+ */
+export declare class TimeOnly {
+    protected _hour: number;
+    protected _minute: number;
+    protected _second: number;
+    protected _millisecond: number;
+    constructor(_hour: number, _minute: number, _second: number, _millisecond: number);
+    readonly declaredRootClass: string;
+    get hour(): number;
+    get minute(): number;
+    get second(): number;
+    get millisecond(): number;
+    equals(v: any): boolean;
+    clone(): TimeOnly;
+    isValid(): boolean;
+    toString(): string;
+    toSQLValue(): string;
+    toSQLWithKeyword(): string;
+    toStorageString(): string;
+    toFormat(format?: string | null): string;
+    toNumber(): number;
+    static fromParts(hour: number, minute: number, second: number, millisecond: number): TimeOnly | null;
+    static fromReader(value: string | null): TimeOnly | null;
+    static fromMilliseconds(ms: number): TimeOnly | null;
+    static fromDateJS(date: Date): TimeOnly;
+    static fromDateTime(date: DateTime): TimeOnly;
+    static fromSqlTimeStampOffset(date: SqlTimeStampOffset): TimeOnly;
+    static fromString(timestring: string, format?: string | null): TimeOnly | null;
+    plus(format: string, amount: number): TimeOnly | null;
+    toUTCDateTime(): DateTime;
+    difference(time: TimeOnly, format: string): number;
+}

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

@@ -0,0 +1,11 @@
+import { IANAZone, Zone, DateTime } from "luxon";
+/**
+ * A zone with a fixed offset (meaning no DST)
+ * @implements {Zone}
+ */
+export declare class UnknownTimeZone {
+    static instance: IANAZone;
+}
+export declare function isUnknownTimeZone(zone: Zone | string): boolean;
+export declare function substituteUnknownTimezone(zone: Zone | string): Zone | string;
+export declare function adoptTimeZone(date: DateTime, zone: Zone): DateTime;

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

@@ -0,0 +1,122 @@
+import type { DateTime } from "luxon";
+import type { SQLDates } from "./sqlDateParsingUtils";
+import type { SqlTimeStampOffset } from "./SqlTimestampOffset";
+import type { FileRange } from "../PeggyGrammar/sql92grammar";
+type PeggyLocation = FileRange;
+type WithRange<T> = {
+    [P in keyof T]: T[P];
+} & {
+    range: PeggyLocation;
+};
+export type SQLNode = WithRange<BinaryNode | BoolNode | ColumnNode | CurrentTimeNode | DataTypeNode | DateNode | FunctionNode | IntervalNode | IntervalPeriodNode | IntervalQualifierNode | ListNode | NullNode | NumberNode | ParamNode | SearchedCaseNode | SimpleCaseNode | StringNode | TimeNode | TimeStampNode | UnaryNode | WhenNode>;
+export interface SimpleCaseNode {
+    type: "case-expression";
+    format: "simple";
+    clauses: WithRange<WhenNode>[];
+    operand: SQLNode;
+    else: SQLNode;
+    elseRange: PeggyLocation;
+}
+export interface SearchedCaseNode {
+    type: "case-expression";
+    format: "searched";
+    clauses: WithRange<WhenNode>[];
+    else: SQLNode;
+    elseRange: PeggyLocation;
+}
+export interface WhenNode {
+    type: "when-clause";
+    operand: SQLNode;
+    value: SQLNode;
+}
+export interface ParamNode {
+    type: "parameter";
+    value: "string";
+}
+export interface ListNode {
+    type: "expression-list";
+    value: SQLNode[];
+}
+export interface UnaryNode {
+    type: "unary-expression";
+    expr: SQLNode;
+}
+export interface BinaryNode {
+    type: "binary-expression";
+    operator: BinaryOperator;
+    left: SQLNode;
+    right: SQLNode;
+    escape?: string;
+}
+export interface NullNode {
+    type: "null";
+    value: null;
+}
+export interface BoolNode {
+    type: "boolean";
+    value: boolean;
+}
+export interface StringNode {
+    type: "string";
+    value: string;
+}
+export interface NumberNode {
+    type: "number";
+    value: number;
+}
+export interface DateNode {
+    type: "date";
+    value: string;
+    parsedValue?: SQLDates;
+}
+export interface TimeNode {
+    type: "time";
+    value: string;
+}
+export interface TimeStampNode {
+    type: "timestamp";
+    value: string;
+    withtimezone?: boolean;
+    parsedValue?: DateTime | SqlTimeStampOffset;
+}
+export interface ColumnNode {
+    type: "column-reference";
+    column: string;
+    delimited?: boolean;
+}
+export interface CurrentTimeNode {
+    type: "current-time";
+    mode: "date" | "timestamp";
+}
+export interface IntervalNode {
+    type: "interval";
+    value: WithRange<ParamNode | StringNode>;
+    op: "-" | "" | "+";
+    qualifier: WithRange<IntervalPeriodNode | IntervalQualifierNode>;
+}
+export interface IntervalQualifierNode {
+    type: "interval-qualifier";
+    start: WithRange<IntervalPeriodNode>;
+    end: WithRange<IntervalPeriodNode>;
+}
+export interface IntervalPeriodNode {
+    type: "interval-period";
+    period: "day" | "hour" | "minute" | "month" | "second" | "year";
+    precision: number;
+    secondary: number;
+}
+export interface FunctionNode {
+    type: "function";
+    name: string;
+    args: WithRange<ListNode>;
+}
+export type BinaryOperator = "-" | "*" | "/" | "+" | "<" | "<=" | "<>" | "=" | ">" | ">=" | "||" | "AND" | "BETWEEN" | "IN" | "IS" | "ISNOT" | "LIKE" | "NOT IN" | "NOT LIKE" | "NOTBETWEEN" | "OR";
+export interface DataTypeNode {
+    type: "data-type";
+    value: {
+        type: "date" | "float" | "integer" | "real" | "smallint" | "time" | "timestamp" | "varchar";
+        size?: number;
+        withtimezone?: boolean;
+    };
+}
+export {};

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

@@ -0,0 +1,5 @@
+export type SqlComparisonOperator = "<" | "<=" | "<>" | "=" | ">" | ">=";
+export declare function isDateTimeComparableValue(dt: any): boolean;
+export declare function isDateOrTimeValue(dt: any): boolean;
+export declare function dateValueInMilliseconds(dt: any): number;
+export declare function sqlCompare(left: any, right: any, operator: SqlComparisonOperator, _defaultTimeZone: string): boolean | null;

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

@@ -0,0 +1,18 @@
+import { DateOnly } from "./DateOnly";
+import { SqlInterval } from "./SqlInterval";
+import { SqlTimeStampOffset } from "./SqlTimestampOffset";
+import { TimeOnly } from "./TimeOnly";
+import { DateTime } from "luxon";
+export type SQLDates = DateOnly | DateTime | SqlTimeStampOffset;
+export declare function convertToExecutingTimeZone(dt: Date, timeReferenceZone: string): DateTime;
+export declare function isNumber(value: any): value is number;
+export declare function isString(value: any): value is string;
+export declare function isSqlInterval(value: any): value is SqlInterval;
+export declare function isDate(v: any): v is Date;
+export declare function isDateTime(v: any): v is DateTime;
+export declare function isDateOnly(v: any): v is DateOnly;
+export declare function isTimeOnly(v: any): v is TimeOnly;
+export declare function isTimestampOffset(v: any): v is SqlTimeStampOffset;
+export declare function parseTime(v: string): TimeOnly;
+export declare function parseTimestamp(v: string, timeReferenceZone: string, _withtimezoneexplicit?: boolean): DateTime | SqlTimeStampOffset;
+export declare function parseDate(v: string, timeReferenceZone: string): SQLDates;

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

@@ -0,0 +1,6 @@
+import type { IntervalPeriodNode, IntervalQualifierNode } from "./support";
+import { FeatureServiceDatabaseType } from "./support";
+export declare function evaluateNodeToWhereClause(node: any, dbtype: FeatureServiceDatabaseType): string[] | string;
+export declare function translateFunctionToDatabaseSpecific(functionname: string, params: any[], dbtype: FeatureServiceDatabaseType): string;
+export declare function makeToday(justdate: boolean, dbtype: FeatureServiceDatabaseType): string;
+export declare function convertIntervalToSql(value: string, qualifier: IntervalQualifierNode | IntervalPeriodNode, op: "+" | "-" | ""): string;

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

@@ -0,0 +1,156 @@
+import { DateTime } from "luxon";
+import { DateOnly } from "./DateOnly";
+import type { SqlTimeStampOffset } from "./SqlTimestampOffset";
+import { TimeOnly } from "./TimeOnly";
+export declare const standardizedFunctions: {
+    extract: {
+        minParams: number;
+        maxParams: number;
+        evaluate: ([type, date]: [string, Date | DateOnly | SqlTimeStampOffset | TimeOnly]) => number | null;
+    };
+    substring: {
+        minParams: number;
+        maxParams: number;
+        evaluate: (params: any[]) => any;
+    };
+    position: {
+        minParams: number;
+        maxParams: number;
+        evaluate: ([find, text]: [string, string]) => number | null;
+    };
+    trim: {
+        minParams: number;
+        maxParams: number;
+        evaluate: (params: any[]) => string | null;
+    };
+    abs: {
+        minParams: number;
+        maxParams: number;
+        evaluate: (params: any[]) => number | null;
+    };
+    ceiling: {
+        minParams: number;
+        maxParams: number;
+        evaluate: (params: any[]) => number | null;
+    };
+    floor: {
+        minParams: number;
+        maxParams: number;
+        evaluate: (params: any[]) => number | null;
+    };
+    log: {
+        minParams: number;
+        maxParams: number;
+        evaluate: (params: any[]) => number | null;
+    };
+    log10: {
+        minParams: number;
+        maxParams: number;
+        evaluate: (params: any[]) => number | null;
+    };
+    sin: {
+        minParams: number;
+        maxParams: number;
+        evaluate: (params: any[]) => number | null;
+    };
+    cos: {
+        minParams: number;
+        maxParams: number;
+        evaluate: (params: any[]) => number | null;
+    };
+    tan: {
+        minParams: number;
+        maxParams: number;
+        evaluate: (params: any[]) => number | null;
+    };
+    asin: {
+        minParams: number;
+        maxParams: number;
+        evaluate: (params: any[]) => number | null;
+    };
+    acos: {
+        minParams: number;
+        maxParams: number;
+        evaluate: (params: any[]) => number | null;
+    };
+    atan: {
+        minParams: number;
+        maxParams: number;
+        evaluate: (params: any[]) => number | null;
+    };
+    sign: {
+        minParams: number;
+        maxParams: number;
+        evaluate: (params: any[]) => 0 | 1 | -1 | null;
+    };
+    power: {
+        minParams: number;
+        maxParams: number;
+        evaluate: (params: any[]) => number | null;
+    };
+    mod: {
+        minParams: number;
+        maxParams: number;
+        evaluate: (params: any[]) => number | null;
+    };
+    round: {
+        minParams: number;
+        maxParams: number;
+        evaluate: (params: any[]) => number | null;
+    };
+    truncate: {
+        minParams: number;
+        maxParams: number;
+        evaluate: (params: any[]) => number | null;
+    };
+    char_length: {
+        minParams: number;
+        maxParams: number;
+        evaluate: (params: any[]) => any;
+    };
+    concat: {
+        minParams: number;
+        maxParams: number;
+        evaluate: (params: any[]) => string | null;
+    };
+    lower: {
+        minParams: number;
+        maxParams: number;
+        evaluate: (params: any[]) => any;
+    };
+    upper: {
+        minParams: number;
+        maxParams: number;
+        evaluate: (params: any[]) => any;
+    };
+    coalesce: {
+        minParams: number;
+        maxParams: number;
+        evaluate: (params: any[]) => any;
+    };
+    cosh: {
+        minParams: number;
+        maxParams: number;
+        evaluate: (params: any[]) => number | null;
+    };
+    sinh: {
+        minParams: number;
+        maxParams: number;
+        evaluate: (params: any[]) => number | null;
+    };
+    tanh: {
+        minParams: number;
+        maxParams: number;
+        evaluate: (params: any[]) => number | null;
+    };
+    nullif: {
+        minParams: number;
+        maxParams: number;
+        evaluate: (params: any[], timeReferenceZone: string) => any;
+    };
+    cast: {
+        minParams: number;
+        maxParams: number;
+        evaluate: (params: any[], timeReferenceZone: string) => string | number | DateTime<boolean> | SqlTimeStampOffset | DateOnly | TimeOnly | null;
+    };
+};

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

@@ -0,0 +1,150 @@
+import { Zone, IANAZone, DateTime } from "luxon";
+export declare enum SqlErrorCodes {
+    InvalidFunctionParameters = "InvalidFunctionParameters",
+    InvalidValueForAggregateFunction = "InvalidValueForAggregateFunction",
+    UnsupportedSqlFunction = "UnsupportedSqlFunction",
+    UnsupportedOperator = "UnsupportedOperator",
+    UnsupportedSyntax = "UnsupportedSyntax",
+    UnsupportedIsRhs = "UnsupportedIsRhs",
+    UnsupportedIsLhs = "UnsupportedIsLhs",
+    InvalidDataType = "InvalidDataType",
+    CannotCastValue = "CannotCastValue",
+    FunctionNotRecognized = "FunctionNotRecognized",
+    InvalidTime = "InvalidTime",
+    InvalidParameterCount = "InvalidParameterCount",
+    InvalidTimeStamp = "InvalidTimeStamp",
+    InvalidDate = "InvalidDate",
+    InvalidOperator = "InvalidOperator",
+    IllegalInterval = "IllegalInterval",
+    YearMonthIntervals = "YearMonthIntervals",
+    PrimarySecondaryQualifiers = "PrimarySecondaryQualifiers",
+    MissingStatisticParameters = "MissingStatisticParameters"
+}
+export declare const sqlErrorMessages: {
+    [key in SqlErrorCodes]: string;
+};
+export declare class SqlError extends Error {
+    readonly declaredRootClass: string;
+    constructor(errorCode: SqlErrorCodes, subs?: Record<string, string>);
+}
+export declare function getDeepValue<T = any>(property: string, target: any): T | undefined;
+export type ReplaceCallback = (substring: string, ...args: any[]) => string;
+type Nil = null | undefined;
+/**
+ * Replaces keys in a template string.
+ * Keys are surrounded by curly braces to be detected
+ *
+ * @param {string} template The input template string
+ * @param {object|Function} map either a data object to lookup for the key's value
+ *                              or a function that will be called with the input key.
+ *
+ * @return a string with the keys replaced.
+ */
+export declare function replace(template: string, map: Nil | ReplaceCallback | object): string;
+/**
+ * Escapes special characters in a string used in a regular expression.
+ *
+ * @param regExpString The input string to escape.
+ * @param [except] Special characters to be left unescaped.
+ *
+ * @ignore
+ */
+export declare function escapeRegExpString(regExpString: string, except?: string): string;
+export interface IntervalPeriodNode {
+    type: "interval-period";
+    period: "day" | "hour" | "minute" | "month" | "second" | "year";
+    precision: number;
+    secondary: number;
+}
+export interface IntervalQualifierNode {
+    type: "interval-qualifier";
+    start: IntervalPeriodNode;
+    end: IntervalPeriodNode;
+}
+export declare enum FeatureServiceDatabaseType {
+    Standardised = 0,
+    StandardisedNoInterval = 1,
+    SqlServer = 2,
+    Oracle = 3,
+    Postgres = 4,
+    PGDB = 5,
+    FILEGDB = 6,
+    NotEvaluated = 7
+}
+export declare function isInteger(value: any): value is number;
+export declare function getDefaultLocale(): string;
+export declare function getLocale(): string;
+/**
+ * A zone with a fixed offset (meaning no DST)
+ * @implements {Zone}
+ */
+export declare class UnknownTimeZone {
+    static instance: IANAZone;
+}
+export declare enum ArcadeDateErrorCodes {
+    TimeZoneNotRecognized = "TimeZoneNotRecognized"
+}
+export declare const arcadeDateErrorMessages: {
+    [key in ArcadeDateErrorCodes]: string;
+};
+export declare class ArcadeDateError extends Error {
+    readonly declaredRootClass: string;
+    constructor(errorCode: ArcadeDateErrorCodes, subs?: Record<string, string>);
+}
+export declare function createDateTimeZone(timeZone: Zone | string, errorIfInvalid?: boolean): Nil | Zone | string;
+export declare class ArcadeDate {
+    protected _date: DateTime;
+    private constructor();
+    readonly declaredRootClass: string;
+    static fromParts(year: number | undefined, month: number | undefined, day: number | undefined, hours: number | undefined, minutes: number | undefined, seconds: number | undefined, millis: number | undefined, timeZone: Zone | string): ArcadeDate | null;
+    static get systemTimeZoneCanonicalName(): string;
+    static arcadeDateAndZoneToArcadeDate(d: ArcadeDate, zone: Zone | string): ArcadeDate;
+    static dateJSToArcadeDate(dt: Date): ArcadeDate;
+    static dateJSAndZoneToArcadeDate(dt: Date, zone?: Zone | string): ArcadeDate;
+    static unknownEpochToArcadeDate(millis: number): ArcadeDate;
+    static unknownDateJSToArcadeDate(d: Date): ArcadeDate;
+    static epochToArcadeDate(millis: number, zone?: Zone | string): ArcadeDate;
+    static dateTimeToArcadeDate(dt: DateTime): ArcadeDate;
+    clone(): ArcadeDate;
+    changeTimeZone(timez: Zone | string): ArcadeDate;
+    static dateTimeAndZoneToArcadeDate(dt: DateTime, zone: Zone | string): ArcadeDate | null;
+    static nowToArcadeDate(zone: Zone | string): ArcadeDate;
+    static nowUTCToArcadeDate(): ArcadeDate;
+    get isSystem(): boolean;
+    equals(test: ArcadeDate): boolean;
+    get isUnknownTimeZone(): boolean;
+    get isValid(): boolean;
+    get hour(): number;
+    get second(): number;
+    get day(): number;
+    get dayOfWeekISO(): number;
+    get dayOfWeekJS(): number;
+    get millisecond(): number;
+    get monthISO(): number;
+    get weekISO(): number;
+    get yearISO(): number;
+    get monthJS(): number;
+    get year(): number;
+    get minute(): number;
+    get zone(): Zone;
+    get timeZoneOffset(): number;
+    get timeZone(): string;
+    stringify(): string;
+    plus(plusoptions: any): ArcadeDate;
+    diff(targetDateTime: ArcadeDate, unit?: "days" | "hours" | "milliseconds" | "minutes" | "months" | "seconds" | "years"): number;
+    toISODate(): string;
+    toISOString(suppressMilliseconds: boolean): string;
+    toISOTime(suppressMilliseconds: boolean, includeOffset: boolean): string;
+    toFormat(format: string, localeinfo: any): string;
+    toJSDate(): Date;
+    toSQLValue(): string;
+    toSQLWithKeyword(): string;
+    toDateTime(): DateTime;
+    toNumber(): number;
+    getTime(): number;
+    toUTC(): ArcadeDate;
+    toLocal(): ArcadeDate;
+    toString(): string;
+    static fromReaderAsTimeStampOffset(v: string | null): ArcadeDate | null;
+}
+export {};