igniteui-react-grids
Version:
Ignite UI React grid components.
1,183 lines • 1.07 MB
JavaScript
/*
THIS INFRAGISTICS ULTIMATE SOFTWARE LICENSE AGREEMENT ("AGREEMENT") LOCATED HERE:
https://www.infragistics.com/legal/license/igultimate-la
https://www.infragistics.com/legal/license/igultimate-eula
GOVERNS THE LICENSING, INSTALLATION AND USE OF INFRAGISTICS SOFTWARE. BY DOWNLOADING AND/OR INSTALLING AND USING INFRAGISTICS SOFTWARE: you are indicating that you have read and understand this Agreement, and agree to be legally bound by it on behalf of the yourself and your company.
*/
import { Base, Type, markType, typeCast, enumGetBox, Date_$type, delegateCombine, delegateRemove, runOn, PropertyChangedEventArgs, String_$type, Number_$type, Boolean_$type, EnumUtil, Delegate_$type, typeGetValue, INotifyPropertyChanged_$type, IList$1_$type, EventArgs, NotSupportedException, Point_$type, fromEnum, fromEn, toNullable, getInstanceType, Array_$type } from "igniteui-react-core";
import { DataSourceSchemaPropertyType_$type } from "igniteui-react-core";
import { ColumnComparisonConditionOperatorType_$type } from "./ColumnComparisonConditionOperatorType";
import { List$1 } from "igniteui-react-core";
import { FilterFactory } from "igniteui-react-core";
import { CultureInfo } from "igniteui-react-core";
import { dateGetMonth, dateMinValue, dateNow } from "igniteui-react-core";
import { tryParseInt32_1 } from "igniteui-react-core";
import { stringStartsWith, stringEmpty, stringIsNullOrWhiteSpace, createGuid, stringReplace, stringRemove, stringIsNullOrEmpty, stringContains } from "igniteui-react-core";
import { dateTryParse, dateParse } from "igniteui-react-core";
import { ObservableCollection$1 } from "igniteui-react-core";
import { IDataSource_$type } from "igniteui-react-core";
import { Brush } from "igniteui-react-core";
import { ScrollbarStyle_$type } from "igniteui-react-core";
import { RowPath } from "./RowPath";
import { GridCellPosition } from "./GridCellPosition";
import { EditModeType_$type } from "./EditModeType";
import { ControlDisplayDensity_$type } from "igniteui-react-core";
import { GridViewportChangedEventArgs } from "./GridViewportChangedEventArgs";
import { ICellModelExportUpdater_$type } from "./ICellModelExportUpdater";
import { XButton } from "igniteui-react-inputs";
import { XIcon } from "igniteui-react-inputs";
import { FontInfo } from "igniteui-react-core";
import { AppearanceHelper } from "igniteui-react-core";
import { stringFormat, isDigit } from "igniteui-react-core";
import { ModelStates_$type } from "./ModelStates";
import { HashSet$1 } from "igniteui-react-core";
import { CellPath } from "./CellPath";
import { Rect } from "igniteui-react-core";
import { ModelTypes_$type } from "./ModelTypes";
import { CellContentHorizontalAlignment_$type } from "./CellContentHorizontalAlignment";
import { CellContentVerticalAlignment_$type } from "./CellContentVerticalAlignment";
import { TextCellLineBreakMode_$type } from "./TextCellLineBreakMode";
import { ColumnSortDirection_$type } from "./ColumnSortDirection";
import { PinnedPositions_$type } from "./PinnedPositions";
import { Dictionary$2 } from "igniteui-react-core";
import { GridStyleRepository } from "./GridStyleRepository";
import { BrushUtil } from "igniteui-react-core";
import { CellModelExport } from "./CellModelExport";
import { FontUtil } from "igniteui-react-core";
import { DataSourceRowType_$type } from "igniteui-react-core";
import { truncate, isNaN_, intDivide, tryParseNumber } from "igniteui-react-core";
import { GroupSummaryDisplayMode_$type } from "./GroupSummaryDisplayMode";
import { BindingFormatter } from "igniteui-react-core";
import { DateTimeFormats_$type } from "./DateTimeFormats";
import { DateTimeColumnValueFormatter } from "./DateTimeColumnValueFormatter";
import { DateTimeCellModelExport } from "./DateTimeCellModelExport";
import { EditorType_$type } from "./EditorType";
import { EditorCellModelExport } from "./EditorCellModelExport";
import { FilterCellModelExport } from "./FilterCellModelExport";
import { SummaryCellModelExport } from "./SummaryCellModelExport";
import { ImageStretchOptions_$type } from "./ImageStretchOptions";
import { ImageResourceType_$type } from "./ImageResourceType";
import { ImageCellModelExport } from "./ImageCellModelExport";
import { NumericCellModelExport } from "./NumericCellModelExport";
import { RowSeparatorModelExport } from "./RowSeparatorModelExport";
import { GroupData } from "./GroupData";
import { SummaryData } from "./SummaryData";
import { SectionHeaderCellModelExport } from "./SectionHeaderCellModelExport";
import { DataSourceSummaryOperand_$type } from "igniteui-react-core";
import { TemplateCellModelExport } from "./TemplateCellModelExport";
import { TextCellModelExport } from "./TextCellModelExport";
import { SortIndicatorStyle_$type } from "./SortIndicatorStyle";
import { ColumnOptionsIconAlignment_$type } from "./ColumnOptionsIconAlignment";
import { ColumnOptionsIconBehavior_$type } from "./ColumnOptionsIconBehavior";
import { TextHeaderCellModelExport } from "./TextHeaderCellModelExport";
import { PagedDataSource } from "igniteui-react-core";
import { SRProvider } from "igniteui-react-core";
import { SummaryScope_$type } from "./SummaryScope";
import { GroupHeaderDisplayMode_$type } from "./GroupHeaderDisplayMode";
import { PageChangedEventArgs } from "./PageChangedEventArgs";
import { ColumnSummaryDescriptionCollection } from "./ColumnSummaryDescriptionCollection";
import { LocalDataSource } from "igniteui-react-core";
import { VirtualDataSource } from "igniteui-react-core";
import { SortDescription } from "igniteui-react-core";
import { FilterExpressionCollection } from "igniteui-react-core";
import { SummaryDescription } from "igniteui-react-core";
import { GridFilterExpressionsEventArgs } from "./GridFilterExpressionsEventArgs";
import { GridSortDescriptionsChangedEventArgs } from "./GridSortDescriptionsChangedEventArgs";
import { GridGroupDescriptionsChangedEventArgs } from "./GridGroupDescriptionsChangedEventArgs";
import { GridSummaryDescriptionsChangedEventArgs } from "./GridSummaryDescriptionsChangedEventArgs";
import { IDataSourceUpdateNotifier_$type } from "igniteui-react-core";
import { MultipleDataSourceNotifier } from "./MultipleDataSourceNotifier";
import { ColumnSortDescription } from "./ColumnSortDescription";
import { ColumnSortDescriptionCollection } from "./ColumnSortDescriptionCollection";
import { ColumnGroupDescription } from "./ColumnGroupDescription";
import { ColumnGroupDescriptionCollection } from "./ColumnGroupDescriptionCollection";
import { ColumnSummaryDescription } from "./ColumnSummaryDescription";
import { PagerVisualModelExport } from "./PagerVisualModelExport";
import { DataSourceSectionHeaderDisplayMode_$type } from "igniteui-react-core";
import { DataSourceSummaryScope_$type } from "igniteui-react-core";
import { DataSourceLocalDataProvider } from "igniteui-react-core";
import { DefinitionPropertyUpdatedEventArgs } from "./DefinitionPropertyUpdatedEventArgs";
import { CellPropertyAnimationType_$type } from "./CellPropertyAnimationType";
import { ColumnResizingMode_$type } from "./ColumnResizingMode";
import { ColumnMovingMode_$type } from "./ColumnMovingMode";
import { Thickness } from "igniteui-react-core";
import { ColumnWidth } from "./ColumnWidth";
import { HeaderClickAction_$type } from "./HeaderClickAction";
import { EditModeClickAction_$type } from "./EditModeClickAction";
import { ColumnShowingAnimationMode_$type } from "./ColumnShowingAnimationMode";
import { ColumnPropertyUpdatingAnimationMode_$type } from "./ColumnPropertyUpdatingAnimationMode";
import { CellDataLoadedAnimationMode_$type } from "./CellDataLoadedAnimationMode";
import { RowSelectionAnimationMode_$type } from "./RowSelectionAnimationMode";
import { RowHoverAnimationMode_$type } from "./RowHoverAnimationMode";
import { CellSelectionAnimationMode_$type } from "./CellSelectionAnimationMode";
import { GridColumnAnimationSettings } from "./GridColumnAnimationSettings";
import { GridAnimationSettings } from "./GridAnimationSettings";
import { ColumnResizingAnimationMode_$type } from "./ColumnResizingAnimationMode";
import { ColumnMovingAnimationMode_$type } from "./ColumnMovingAnimationMode";
import { ColumnHidingAnimationMode_$type } from "./ColumnHidingAnimationMode";
import { ColumnExchangingAnimationMode_$type } from "./ColumnExchangingAnimationMode";
import { DataGridSelectionMode_$type } from "./DataGridSelectionMode";
import { GridActivationMode_$type } from "./GridActivationMode";
import { GridSelectionBehavior_$type } from "./GridSelectionBehavior";
import { GridSelectedItemsCollection } from "./GridSelectedItemsCollection";
import { GridSelectedKeysCollection } from "./GridSelectedKeysCollection";
import { GridSelectedCellRangesCollection } from "./GridSelectedCellRangesCollection";
import { CornerRadius } from "igniteui-react-core";
import { SortGroupParser } from "igniteui-react-core";
import { ListSortDirection_$type } from "igniteui-react-core";
import { SummaryParser } from "igniteui-react-core";
import { IEditableDataSource_$type } from "igniteui-react-core";
import { EnterKeyBehaviors_$type } from "./EnterKeyBehaviors";
import { EnterKeyBehaviorAfterEdit_$type } from "./EnterKeyBehaviorAfterEdit";
import { MergedCellMode_$type } from "./MergedCellMode";
import { MergedCellEvaluationCriteria_$type } from "./MergedCellEvaluationCriteria";
import { FilterUIType_$type } from "./FilterUIType";
import { FilterLogicalOperator_$type } from "./FilterLogicalOperator";
import { FilterComparisonType_$type } from "./FilterComparisonType";
import { CellRange } from "./CellRange";
import { PrimaryKeyValue } from "./PrimaryKeyValue";
import { FastIterationDictionary$2 } from "igniteui-react-core";
import { DeviceUtils } from "igniteui-react-core";
import { DefaultPlatformPixelConverter } from "./DefaultPlatformPixelConverter";
import { GridSelectedItemsChangedEventArgs } from "./GridSelectedItemsChangedEventArgs";
import { GridSelectedKeysChangedEventArgs } from "./GridSelectedKeysChangedEventArgs";
import { GridSelectedCellRangesChangedEventArgs } from "./GridSelectedCellRangesChangedEventArgs";
import { ArgumentException } from "igniteui-react-core";
import { GridDataCommittedEventArgs } from "./GridDataCommittedEventArgs";
import { GridDataCommittingEventArgs } from "./GridDataCommittingEventArgs";
import { DataSourceRootSummariesChangedEventArgs } from "igniteui-react-core";
import { GridSizeChangedEventArgs } from "./GridSizeChangedEventArgs";
import { ColumnStates_$type } from "./ColumnStates";
import { InvalidOperationException } from "igniteui-react-core";
import { VisualModelExport } from "./VisualModelExport";
import { GridActiveCellChangedEventArgs } from "./GridActiveCellChangedEventArgs";
import { GridSelectionChangedEventArgs } from "./GridSelectionChangedEventArgs";
import { Convert } from "igniteui-react-core";
import { GridRowEditStartedEventArgs } from "./GridRowEditStartedEventArgs";
import { GridRowEditEndedEventArgs } from "./GridRowEditEndedEventArgs";
import { JsonDictionaryObject } from "igniteui-react-core";
import { JsonDictionaryArray } from "igniteui-react-core";
import { SaveLayoutSortInfo } from "./SaveLayoutSortInfo";
import { SaveLayoutGroupInfo } from "./SaveLayoutGroupInfo";
import { SaveLayoutFilterInfo } from "./SaveLayoutFilterInfo";
import { JsonDictionaryItem } from "igniteui-react-core";
import { JsonDictionaryValue } from "igniteui-react-core";
import { FunctionFilterExpression } from "igniteui-react-core";
import { OperationFilterExpression } from "igniteui-react-core";
import { LiteralFilterExpression } from "igniteui-react-core";
import { PropertyReferenceFilterExpression } from "igniteui-react-core";
import { JsonDictionaryParser } from "igniteui-react-core";
import { nullableNotEquals, nullableEquals, unwrapNullable, nullableConcat } from "igniteui-react-core";
import { timeSpanTotalSeconds, timeSpanFromMilliseconds, timeSpanTotalMilliseconds } from "igniteui-react-core";
import { GridAnimationPhaseSettings } from "./GridAnimationPhaseSettings";
import { GridAnimationManagerAnimationCreatedEventArgs } from "./GridAnimationManagerAnimationCreatedEventArgs";
import { GridAnimationManagerAnimationCompletedEventArgs } from "./GridAnimationManagerAnimationCompletedEventArgs";
import { GridAnimationManagerAnimationCanceledEventArgs } from "./GridAnimationManagerAnimationCanceledEventArgs";
import { GridColumnSpacer } from "./GridColumnSpacer";
import { GridColumnSpacerCollection } from "./GridColumnSpacerCollection";
import { GridConditionalStylePropertyCollection } from "./GridConditionalStylePropertyCollection";
import { Guid } from "igniteui-react-core";
import { PropertyUpdatedEventArgs } from "igniteui-react-core";
import { GridConditionFilterStringErrorsParsingEventArgs } from "./GridConditionFilterStringErrorsParsingEventArgs";
import { FilterExpressionParsingHelper } from "igniteui-react-core";
import { FilterExpressionEnvironment } from "igniteui-react-core";
import { CellStyleRequestedEventArgs } from "./CellStyleRequestedEventArgs";
import { PlatformAPIHelper } from "igniteui-react-core";
import { BrushCollectionUtil } from "igniteui-react-core";
import { IToolbarTarget_$type } from "igniteui-react-core";
import { LayoutAction_$type } from "./LayoutAction";
import { ToolActionInfo } from "igniteui-react-core";
import { ICommandAvailabilityListener_$type } from "igniteui-react-core";
import { ICommandStateChangedListener_$type } from "igniteui-react-core";
import { Stack$1 } from "igniteui-react-core";
import { DataSourceSpecialRow } from "igniteui-react-core";
import { RowRange } from "./RowRange";
import { DefaultSectionInformation } from "igniteui-react-core";
import { ToolActionCollection } from "igniteui-react-layouts";
import { ToolActionIconMenuInfo } from "igniteui-react-core";
import { ToolActionGroupHeaderInfo } from "igniteui-react-core";
import { ToolActionIconButtonInfo } from "igniteui-react-core";
import { ToolActionButtonPairInfo } from "igniteui-react-core";
import { ToolActionLabelInfo } from "igniteui-react-core";
import { ToolActionCheckboxInfo } from "igniteui-react-core";
import { ToolActionCheckboxListInfo } from "igniteui-react-core";
import { ToolActionSubPanelInfo } from "igniteui-react-core";
import { ToolActionButtonInfo } from "igniteui-react-core";
import { SvgIconRegistry } from "igniteui-react-core";
import { ToolContextBindingInfo } from "igniteui-react-core";
import { LayoutSelectedKeysCollection } from "igniteui-react-layouts";
import { LayoutPrimaryKeyValue } from "igniteui-react-layouts";
import { ToolActionCheckboxListIndexType_$type } from "igniteui-react-layouts";
import { StringComparer } from "igniteui-react-core";
import { Color } from "igniteui-react-core";
import { EasingFunctions } from "igniteui-react-core";
import { MergedCellInfo } from "./MergedCellInfo";
import { CalculationParameters } from "./CalculationParameters";
import { ColumnPropertySettersCollection } from "./ColumnPropertySettersCollection";
import { ColumnPropertySetter } from "./ColumnPropertySetter";
import { ResponsiveStateEnteringEventArgs } from "./ResponsiveStateEnteringEventArgs";
import { ResponsiveStateEnteredEventArgs } from "./ResponsiveStateEnteredEventArgs";
import { ResponsiveStateExitedEventArgs } from "./ResponsiveStateExitedEventArgs";
import { RectData } from "igniteui-react-core";
import { GridLayerExport } from "./GridLayerExport";
/**
* @hidden
*/
export let ColumnFilterCondition = /*@__PURE__*/ (() => {
class ColumnFilterCondition extends Base {
constructor() {
super(...arguments);
this.b = null;
}
isGroup() {
return false;
}
resolveFilter(a, b) {
return null;
}
}
ColumnFilterCondition.$t = /*@__PURE__*/ markType(ColumnFilterCondition, 'ColumnFilterCondition');
return ColumnFilterCondition;
})();
/**
* @hidden
*/
export let ColumnComparisonFilterCondition = /*@__PURE__*/ (() => {
class ColumnComparisonFilterCondition extends ColumnFilterCondition {
constructor() {
super();
this._operator = 0;
this._value = null;
this._isCaseSensitive = false;
this.isCaseSensitive = true;
}
static getApplicableOperators(a) {
let b = new List$1(ColumnComparisonConditionOperatorType_$type, 0);
switch (a) {
case 11: break;
case 2: break;
case 10:
case 6:
case 5:
case 1:
case 3:
case 8:
b.add(4);
b.add(5);
b.add(2);
b.add(3);
break;
case 0:
b.add(14);
b.add(15);
b.add(16);
b.add(17);
b.add(12);
b.add(13);
b.add(4);
b.add(5);
b.add(2);
b.add(3);
break;
}
b.add(0);
b.add(1);
b.add(43);
b.add(42);
return b.toArray();
}
equals(a) {
if (a == null) {
return false;
}
if (!(typeCast(ColumnComparisonFilterCondition.$, a) !== null)) {
return false;
}
let b = a;
if (b.operator != this.operator) {
return false;
}
if (!Base.equalsStatic(b.value, this.value)) {
return false;
}
if (!Base.equalsStatic(b.isCaseSensitive, this.isCaseSensitive)) {
return false;
}
return true;
}
get operator() {
return this._operator;
}
set operator(a) {
this._operator = a;
}
get value() {
return this._value;
}
set value(a) {
this._value = a;
}
get isCaseSensitive() {
return this._isCaseSensitive;
}
set isCaseSensitive(a) {
this._isCaseSensitive = a;
}
resolveFilter(a, b) {
return this.h(a, b, this.operator);
}
h(a, b, c) {
switch (c) {
case 12:
{
if (this.value == null) {
return null;
}
let d = FilterFactory.instance.property(a);
let e = FilterFactory.instance.literal(this.value);
d = ColumnComparisonFilterCondition.g(b, d);
if (null == d) {
return null;
}
if (!this.isCaseSensitive) {
d = d.toLower();
e = e.toLower();
}
return d.contains(e);
}
case 13:
{
if (this.value == null) {
return null;
}
let f = FilterFactory.instance.property(a);
let g = FilterFactory.instance.literal(this.value);
f = ColumnComparisonFilterCondition.g(b, f);
if (null == f) {
return null;
}
if (!this.isCaseSensitive) {
f = f.toLower();
g = g.toLower();
}
return f.contains(g).not();
}
case 17:
{
if (this.value == null) {
return null;
}
let h = FilterFactory.instance.property(a);
let i = FilterFactory.instance.literal(this.value);
h = ColumnComparisonFilterCondition.g(b, h);
if (null == h) {
return null;
}
if (!this.isCaseSensitive) {
h = h.toLower();
i = i.toLower();
}
return h.endsWith(i).not();
}
case 15:
{
if (this.value == null) {
return null;
}
let j = FilterFactory.instance.property(a);
let k = FilterFactory.instance.literal(this.value);
j = ColumnComparisonFilterCondition.g(b, j);
if (null == j) {
return null;
}
if (!this.isCaseSensitive) {
j = j.toLower();
k = k.toLower();
}
return j.startsWith(k).not();
}
case 16:
{
if (this.value == null) {
return null;
}
let l = FilterFactory.instance.property(a);
let m = FilterFactory.instance.literal(this.value);
l = ColumnComparisonFilterCondition.g(b, l);
if (null == l) {
return null;
}
if (!this.isCaseSensitive) {
l = l.toLower();
m = m.toLower();
}
return l.endsWith(m);
}
case 0:
{
let n = FilterFactory.instance.property(a);
let o = FilterFactory.instance.literal(this.k(this.value, b));
if (b == 0 && !this.isCaseSensitive) {
n = n.toLower();
o = o.toLower();
}
else if (b == 8) {
return n.day().isEqualTo(o.day()).and(n.month().isEqualTo(o.month())).and(n.year().isEqualTo(o.year()));
}
else if (b == 2) {
if (this.value != null && typeof this.value === 'string') {
switch (this.value.toString().toLowerCase()) {
case "true":
o = FilterFactory.instance.literal(true);
break;
case "false":
o = FilterFactory.instance.literal(false);
break;
}
}
}
return n.isEqualTo(o);
}
case 4:
{
let p = this.k(this.value, b);
let q = FilterFactory.instance.property(a);
let r = FilterFactory.instance.literal(p);
if (b == 0 && !this.isCaseSensitive) {
q = q.toLower();
r = r.toLower();
}
else if (b == 8) {
let s = p;
return q.year().isGreaterThan(s.getFullYear()).or(q.year().isEqualTo(s.getFullYear()).and(q.month().isGreaterThan(dateGetMonth(s)).or(q.month().isEqualTo(dateGetMonth(s)).and(q.day().isGreaterThan(s.getDate())))));
}
return q.isGreaterThan(r);
}
case 5:
{
let t = this.k(this.value, b);
let u = FilterFactory.instance.property(a);
let v = FilterFactory.instance.literal(t);
if (b == 0 && !this.isCaseSensitive) {
u = u.toLower();
v = v.toLower();
}
else if (b == 8) {
let w = t;
return u.year().isGreaterThan(w.getFullYear()).or(u.year().isEqualTo(w.getFullYear()).and(u.month().isGreaterThan(dateGetMonth(w)).or(u.month().isEqualTo(dateGetMonth(w)).and(u.day().isGreaterThanOrEqualTo(w.getDate())))));
}
return u.isGreaterThanOrEqualTo(v);
}
case 2:
{
let x = this.k(this.value, b);
let y = FilterFactory.instance.property(a);
let z = FilterFactory.instance.literal(x);
if (b == 0 && !this.isCaseSensitive) {
y = y.toLower();
z = z.toLower();
}
else if (b == 8) {
let aa = x;
return y.year().isLessThan(aa.getFullYear()).or(y.year().isEqualTo(aa.getFullYear()).and(y.month().isLessThan(dateGetMonth(aa)).or(y.month().isEqualTo(dateGetMonth(aa)).and(y.day().isLessThan(aa.getDate())))));
}
return y.isLessThan(z);
}
case 3:
{
let ab = this.k(this.value, b);
let ac = FilterFactory.instance.property(a);
let ad = FilterFactory.instance.literal(ab);
if (b == 0 && !this.isCaseSensitive) {
ac = ac.toLower();
ad = ad.toLower();
}
else if (b == 8) {
let ae = ab;
return ac.year().isLessThan(ae.getFullYear()).or(ac.year().isEqualTo(ae.getFullYear()).and(ac.month().isLessThan(dateGetMonth(ae)).or(ac.month().isEqualTo(dateGetMonth(ae)).and(ac.day().isLessThanOrEqualTo(ae.getDate())))));
}
return ac.isLessThanOrEqualTo(ad);
}
case 1:
{
let af = FilterFactory.instance.property(a);
let ag = FilterFactory.instance.literal(this.k(this.value, b));
if (b == 0 && !this.isCaseSensitive) {
af = af.toLower();
ag = ag.toLower();
}
else if (b == 8) {
return af.day().isNotEqualTo(ag.day()).or(af.month().isNotEqualTo(ag.month())).or(af.year().isNotEqualTo(ag.year()));
}
return af.isNotEqualTo(ag);
}
case 14:
{
if (this.value == null) {
return null;
}
let ah = FilterFactory.instance.property(a);
let ai = FilterFactory.instance.literal(this.value);
ah = ColumnComparisonFilterCondition.g(b, ah);
if (null == ah) {
return null;
}
if (!this.isCaseSensitive) {
ah = ah.toLower();
ai = ai.toLower();
}
return ah.startsWith(ai);
}
case 43:
{
let aj = FilterFactory.instance.property(a);
let ak = FilterFactory.instance.literal(null);
return aj.isNotEqualTo(ak);
}
case 42:
{
let al = FilterFactory.instance.property(a);
let am = FilterFactory.instance.literal(null);
return al.isEqualTo(am);
}
case 38:
{
let an = FilterFactory.instance.property(a);
let ao = 0;
if (typeof this.value === 'string') {
let ap = this.value;
if (((() => { let aq = tryParseInt32_1(ap, ao); ao = aq.p1; return aq.ret; })())) {
let aq = FilterFactory.instance.literal(ao);
return an.month().isEqualTo(aq);
}
else {
let ar = null;
let as = CultureInfo.currentCulture.dateTimeFormat.monthNames;
for (let at = 0; at < as.length; at++) {
if (stringStartsWith(as[at].toLowerCase(), ap.toLowerCase())) {
let au = FilterFactory.instance.literal(at + 1);
if (ar == null) {
ar = an.month().isEqualTo(au);
}
else {
ar = FilterFactory.instance.or(ar, an.month().isEqualTo(au));
}
}
}
return ar;
}
}
else {
let av = FilterFactory.instance.literal(this.value);
return an.month().isEqualTo(av);
}
}
case 39:
{
let aw = this.value;
if (typeof aw === 'string') {
let ax = -1;
if (((() => { let ay = tryParseInt32_1(aw, ax); ax = ay.p1; return ay.ret; })())) {
aw = ax;
}
else {
aw = -1;
}
}
let ay = FilterFactory.instance.property(a);
let az = FilterFactory.instance.literal(aw);
return ay.year().isEqualTo(az);
}
case 10:
{
let a0 = FilterFactory.instance.property(a);
let a1 = FilterFactory.instance.literal(true);
return a0.isEqualTo(a1);
}
case 11:
{
let a2 = FilterFactory.instance.property(a);
let a3 = FilterFactory.instance.literal(false);
return a2.isEqualTo(a3);
}
case 40:
{
let a4 = FilterFactory.instance.property(a);
let a5 = FilterFactory.instance.literal("");
return a4.isEqualTo(a5);
}
case 41:
{
let a6 = FilterFactory.instance.property(a);
let a7 = FilterFactory.instance.literal("");
return a6.isNotEqualTo(a7);
}
case 18:
{
let a8 = FilterFactory.instance.property(a);
return a8.isToday();
}
case 19:
{
let a9 = FilterFactory.instance.property(a);
return a9.isTomorrow();
}
case 20:
{
let ba = FilterFactory.instance.property(a);
return ba.isYesterday();
}
case 22:
{
let bb = FilterFactory.instance.property(a);
return bb.isThisWeek();
}
case 21:
{
let bc = FilterFactory.instance.property(a);
return bc.isNextWeek();
}
case 23:
{
let bd = FilterFactory.instance.property(a);
return bd.isLastWeek();
}
case 25:
{
let be = FilterFactory.instance.property(a);
return be.isThisMonth();
}
case 24:
{
let bf = FilterFactory.instance.property(a);
return bf.isNextMonth();
}
case 26:
{
let bg = FilterFactory.instance.property(a);
return bg.isLastMonth();
}
case 31:
{
let bh = FilterFactory.instance.property(a);
return bh.isThisYear();
}
case 30:
{
let bi = FilterFactory.instance.property(a);
return bi.isNextYear();
}
case 32:
{
let bj = FilterFactory.instance.property(a);
return bj.isLastYear();
}
case 33:
{
let bk = FilterFactory.instance.property(a);
return bk.isYearToDate();
}
case 28:
{
let bl = FilterFactory.instance.property(a);
return bl.isThisQuarter();
}
case 27:
{
let bm = FilterFactory.instance.property(a);
return bm.isNextQuarter();
}
case 29:
{
let bn = FilterFactory.instance.property(a);
return bn.isLastQuarter();
}
case 34:
{
let bo = FilterFactory.instance.property(a);
return bo.isQ1();
}
case 35:
{
let bp = FilterFactory.instance.property(a);
return bp.isQ2();
}
case 36:
{
let bq = FilterFactory.instance.property(a);
return bq.isQ3();
}
case 37:
{
let br = FilterFactory.instance.property(a);
return br.isQ4();
}
}
return null;
}
static g(a, b) {
switch (a) {
case 9:
case 8:
case 2:
case 11: return null;
case 10:
case 6:
case 5:
case 1:
case 3:
case 4:
case 7: return b.cast(enumGetBox(DataSourceSchemaPropertyType_$type, 0));
case 0: break;
default: break;
}
return b;
}
static getOperandNumber(a) {
if (a == 43 || a == 42) {
return 0;
}
else {
return 1;
}
}
static getOperandNumbers(a) {
let b = new Array(a.length);
for (let c = 0; c < a.length; c++) {
b[c] = ColumnComparisonFilterCondition.getOperandNumber(a[c]);
}
return b;
}
k(value_, a) {
if (value_ == null) {
return null;
}
switch (a) {
case 2: return (!!value_);
case 10: return (+value_);
case 8:
if (typeCast(Date_$type, value_) !== null) {
return value_;
}
if (typeof value_ === 'string') {
let b;
if (((() => { let c = dateTryParse(value_, b); b = c.p1; return c.ret; })())) {
return b;
}
else {
return null;
}
}
return (new Date(+value_));
case 6: return (+value_);
case 5: return (+value_);
case 1: return (+value_);
case 3: return (+value_);
case 11: return value_;
case 4: return (+value_);
case 7: return (+value_);
case 0: return value_ != null ? value_.toString() : value_;
}
return value_;
}
}
ColumnComparisonFilterCondition.$t = /*@__PURE__*/ markType(ColumnComparisonFilterCondition, 'ColumnComparisonFilterCondition', ColumnFilterCondition.$);
return ColumnComparisonFilterCondition;
})();
/**
* @hidden
*/
export let ColumnCustomFilterCondition = /*@__PURE__*/ (() => {
class ColumnCustomFilterCondition extends ColumnFilterCondition {
constructor() {
super(...arguments);
this._value = null;
this._id = null;
this._index = 0;
}
get value() {
return this._value;
}
set value(a) {
this._value = a;
}
get id() {
return this._id;
}
set id(a) {
this._id = a;
}
get index() {
return this._index;
}
set index(a) {
this._index = a;
}
resolveFilter(a, b) {
let c = this.b.h4(this.id, this.index);
return this.b.g4(c, this.value);
}
}
ColumnCustomFilterCondition.$t = /*@__PURE__*/ markType(ColumnCustomFilterCondition, 'ColumnCustomFilterCondition', ColumnFilterCondition.$);
return ColumnCustomFilterCondition;
})();
/**
* @hidden
*/
export let ColumnFilterConditionCollection = /*@__PURE__*/ (() => {
class ColumnFilterConditionCollection extends ObservableCollection$1 {
constructor() {
super(ColumnFilterCondition.$, 0);
}
}
ColumnFilterConditionCollection.$t = /*@__PURE__*/ markType(ColumnFilterConditionCollection, 'ColumnFilterConditionCollection', /*@__PURE__*/ ObservableCollection$1.$.specialize(ColumnFilterCondition.$));
return ColumnFilterConditionCollection;
})();
/**
* @hidden
*/
export let ColumnFilterConditionGroup = /*@__PURE__*/ (() => {
class ColumnFilterConditionGroup extends ColumnFilterCondition {
isGroup() {
return true;
}
constructor() {
super();
this._usesOrOperator = false;
this.f = null;
this.f = new ColumnFilterConditionCollection();
this.usesOrOperator = false;
}
equals(a) {
if (a == null) {
return false;
}
if (!(typeCast(ColumnFilterConditionGroup.$, a) !== null)) {
return false;
}
let b = a;
if (b.count != this.count) {
return false;
}
for (let c = 0; c < this.count; c++) {
if (!Base.equalsStatic(this.item(c), b.item(c))) {
return false;
}
}
return true;
}
get count() {
return this.f.count;
}
get usesOrOperator() {
return this._usesOrOperator;
}
set usesOrOperator(a) {
this._usesOrOperator = a;
}
add(a) {
this.f.add(a);
}
remove(a) {
this.f.remove(a);
}
removeAt(a) {
this.f.removeAt(a);
}
item(a, b) {
if (arguments.length === 2) {
this.f._inner[a] = b;
return b;
}
else {
return this.f._inner[a];
}
}
clear() {
this.f.clear();
}
toArray() {
let a = new Array(this.f.count);
for (let b = 0; b < this.f.count; b++) {
a[b] = this.f._inner[b];
}
return a;
}
resolveFilter(a, b) {
if (this.f.count == 0) {
return null;
}
let c = this.f._inner[this.f.count - 1].resolveFilter(a, b);
for (let d = this.f.count - 2; d >= 0; d--) {
if (this.usesOrOperator) {
c = FilterFactory.instance.or(this.f._inner[d].resolveFilter(a, b), c);
}
else {
c = FilterFactory.instance.and(this.f._inner[d].resolveFilter(a, b), c);
}
}
return c;
}
}
ColumnFilterConditionGroup.$t = /*@__PURE__*/ markType(ColumnFilterConditionGroup, 'ColumnFilterConditionGroup', ColumnFilterCondition.$);
return ColumnFilterConditionGroup;
})();
/**
* @hidden
*/
export let IExternalGrid_$type = /*@__PURE__*/ new Type(null, 'IExternalGrid');
/**
* @hidden
*/
export let ICellRenderingEngine_$type = /*@__PURE__*/ new Type(null, 'ICellRenderingEngine');
/**
* @hidden
*/
export let ICellPresenter_$type = /*@__PURE__*/ new Type(null, 'ICellPresenter');
/**
* @hidden
*/
export let ICellActionManager_$type = /*@__PURE__*/ new Type(null, 'ICellActionManager');
/**
* @hidden
*/
export let DefaultCellActionManager = /*@__PURE__*/ (() => {
class DefaultCellActionManager extends Base {
constructor(a, b) {
super();
this.b = null;
this.a = null;
this.c = false;
this.d = false;
this.b = a;
this.a = b;
}
clickExpansionIndicator() {
if (this.b != null && this.a != null) {
this.b.wv(this.a);
}
}
clickCell(a) {
if (this.b != null && this.a != null) {
this.b.vp(this.a, this.c, this.d, a);
}
}
dragStarted() {
if (this.b != null && this.b.ao != null) {
this.b.wt(this.b.ao, this.mousePosition.x, this.mousePosition.y, this.c);
this.mouseUpCell(this.mousePosition.x, this.mousePosition.y);
}
}
previewPointerDownCell() {
if (this.b != null && this.a != null) {
this.b.v0(this.a);
}
}
previewPointerUpCell() {
if (this.b != null && this.a != null) {
this.b.v1(this.a);
}
}
pointerDownCell() {
if (this.b != null && this.a != null) {
this.b.vy(this.a);
}
}
pointerUpCell() {
if (this.b != null && this.a != null) {
this.b.vz(this.a);
}
}
previewMouseDownCell(a, b, c) {
if (this.b != null && this.a != null) {
this.b.w0(this.a, a, b, c);
}
}
previewMouseUpCell(a, b, c) {
if (this.b != null && this.a != null) {
this.b.w1(this.a, a, b, c);
}
}
mouseDownCell(a, b) {
if (this.b != null && this.a != null) {
this.b.vw(this.a, a, b);
}
}
mouseUpCell(a, b) {
if (this.b != null && this.a != null) {
this.b.vx(this.a, a, b);
}
}
mouseLeaveCell(a, b) {
if (this.b != null && this.a != null) {
this.b.vv(this.a, a, b);
}
}
mouseEnterCell(a, b) {
if (this.b != null && this.a != null) {
this.b.vu(this.a, a, b);
}
}
mouseIsOver(a, b) {
if (this.b != null && this.a != null) {
this.b.wz(this.a, a, b);
}
}
doubleClicked(a) {
if (this.b != null && this.a != null) {
this.b.vr(this.a, a);
}
}
getColumnFilterCondition() {
if (this.b == null) {
return null;
}
return this.b.o(this.a);
}
getColumnPropertyType() {
if (this.b == null) {
return 11;
}
return this.b.q(this.a);
}
columnFilterChanging(a) {
if (this.b == null) {
return;
}
this.b.ug(this.a, a);
}
columnFilterChanged(a) {
if (this.b == null) {
return;
}
this.b.uf(this.a, a);
}
isCellDown() {
if (this.b != null && this.b.ao != null && this.a != null) {
return this.b.ao.equals(this.a.l);
}
return false;
}
get isLeaveActionDesired() {
if (this.a.l.h) {
return true;
}
return this.b.isRowHoverEnabled;
}
get isEnterActionDesired() {
return this.b.isRowHoverEnabled;
}
get isClickActionDesired() {
return this.b.ji;
}
get isHoverActionDesired() {
return this.b.j2;
}
get isPreviewPointerDownActionDesired() {
return this.b.j9;
}
get isPreviewPointerUpActionDesired() {
return this.b.ka;
}
get isPointerDownActionDesired() {
return this.b.j7;
}
get isPointerUpActionDesired() {
return this.b.j8;
}
get isControlPressed() {
return this.c;
}
set isControlPressed(a) {
this.c = a;
}
get isShiftPressed() {
return this.d;
}
set isShiftPressed(a) {
this.d = a;
}
get isDrag() {
return this.b.dragger.isDragActive;
}
get isMouseDown() {
return this.b.ao != null;
}
get mousePosition() {
return this.b.abb;
}
get isGridDragging() {
if (this.b != null && this.b.dragger != null) {
return this.b.dragger.isDragActive;
}
else {
return false;
}
}
get isEditRefocusDesired() {
if (this.b != null) {
return this.b.k9();
}
return false;
}
updateCellEditValue(a) {
let b = typeCast(EditorCellModel.$, this.a);
if (b != null) {
b.na = a;
}
let c = this.b.cj;
c.t = a;
if (this.b.model.bx != null && this.b.model.bw != null) {
if (!c.k && (c.r < this.b.model.bx.x || c.r > this.b.model.bw.x)) {
this.b.t9(c.r, c.q, false);
}
}
}
startEditMode() {
if (this.b.editOnKeyPress) {
let a = this.b.cj;
if (this.b.model.bx != null && this.b.model.bw != null) {
if (!a.k && (a.r < this.b.model.bx.x || a.r > this.b.model.bw.x)) {
this.b.t9(a.r, a.q, false);
}
}
}
if (this.b.ju() && !this.b.cj.j && this.b.editOnKeyPress) {
let b = this.b.ad.s();
let c = this.b.model.e(b, this.b.activeCell.b);
this.b.lb(c);
}
}
editorCellLostFocus() {
if (this.b != null) {
this.b.wu(typeCast(EditorCellModel.$, this.a));
}
}
cancelEditMode(a) {
if (this.b != null && this.b.cj.j) {
this.b.ja(a);
if (this.b.editMode == 3) {
this.b.uq(a);
}
}
}
disableKeyInput() {
if (this.b != null) {
this.b.j4 = false;
}
}
enableKeyInput() {
if (this.b != null) {
this.b.j4 = true;
}
}
passCellClone(a) {
if (this.b != null) {
if (this.b.dragger != null) {
this.b.dragger.cloneCell = a;
}
}
}
applyFilter(a, b) {
if (this.b != null) {
let c = thi