@triniwiz/nativescript-masonkit 1.0.0-alpha.34 → 1.0.0-alpha.35

package/utils/index.ios.js

@@ -0,0 +1,710 @@
+import { Length, Utils } from '@nativescript/core';
+import { isMasonView_, style_ } from '../common';
+import { parseUnit } from '@nativescript/core/css/parser';
+// if (__ANDROID__) {
+//   try {
+//     java.lang.System.loadLibrary('masonnative');
+//     __non_webpack_require__('system_lib://libmasonnativev8.so');
+//     UseV8Module = true;
+//   } catch (error) {
+//     console.warn('Failed to enable on FastAPI');
+//   }
+// }
+// if (__APPLE__) {
+//   NSCMason.alwaysEnable = true;
+//   if (!UseV8Module) {
+//     try {
+//       const installer = MasonV8Module.new();
+//       installer.install();
+//       UseV8Module = true;
+//     } catch (error) {
+//       console.warn('Failed to enable on FastAPI');
+//     }
+//   }
+// }
+let sharedMason = null;
+function getNode(instance) {
+    const nativeView = instance?.ios;
+    if (instance[isMasonView_]) {
+        return nativeView.node;
+    }
+    if (!sharedMason) {
+        sharedMason = NSCMason.shared;
+    }
+    return sharedMason.nodeForView(nativeView, true);
+}
+function getStyle(instance) {
+    const nativeView = instance?.ios;
+    if (instance[isMasonView_]) {
+        // @ts-ignore
+        return nativeView.node.style;
+    }
+    if (!sharedMason) {
+        sharedMason = NSCMason.shared;
+    }
+    return sharedMason.nodeForView(nativeView, true).style;
+}
+export function _forceStyleUpdate(instance) {
+    if (!instance._hasNativeView) {
+        return;
+    }
+    // if (__ANDROID__) {
+    //   const nodeOrView = getMasonInstance(instance) as org.nativescript.mason.masonkit.TextView;
+    //   nodeOrView.getStyle().updateNodeAndStyle();
+    // }
+    // if (__APPLE__) {
+    //   (instance.ios as MasonUIView).node.style.updateNativeStyle();
+    // }
+}
+export function _markDirty(instance) {
+    if (!instance._hasNativeView) {
+        return;
+    }
+    getNode(instance).markDirty();
+}
+export function _isDirty(instance) {
+    if (!instance._hasNativeView) {
+        return false;
+    }
+    return getNode(instance).isDirty;
+}
+export function _intoType(type) {
+    switch (type) {
+        case 'auto':
+            return 0 /* MasonDimensionCompatType.Auto */;
+        case 'points':
+            return 1 /* MasonDimensionCompatType.Points */;
+        case 'percent':
+            return 2 /* MasonDimensionCompatType.Percent */;
+        default:
+            return 0 /* MasonDimensionCompatType.Auto */;
+    }
+}
+export function _parseDimension(dim) {
+    const type = dim.type;
+    const value = dim.value;
+    switch (type) {
+        case 0 /* MasonDimensionCompatType.Auto */:
+            return 'auto';
+        case 1 /* MasonDimensionCompatType.Points */:
+            return { value: value, unit: 'px' };
+        case 2 /* MasonDimensionCompatType.Percent */:
+            return { value: value, unit: '%' };
+    }
+}
+export function parseLength(length, parent = 0) {
+    switch (length.unit) {
+        case '%':
+            return length.value * parent;
+        case 'dip':
+            return Utils.layout.toDevicePixels(length.value);
+        case 'px':
+            return length.value;
+    }
+}
+export function _parseLengthPercentage(dim) {
+    const type = dim.type;
+    const value = dim.value;
+    switch (type) {
+        case 0 /* MasonLengthPercentageCompatType.Points */:
+            return { value: value, unit: 'px' };
+        case 1 /* MasonLengthPercentageCompatType.Percent */:
+            return { value: value, unit: '%' };
+    }
+}
+export function _parseLengthPercentageAuto(dim) {
+    const type = dim.type;
+    const value = dim.value;
+    switch (type) {
+        case 0 /* MasonLengthPercentageAutoCompatType.Auto */:
+            return 'auto';
+        case 1 /* MasonLengthPercentageAutoCompatType.Points */:
+            return { value: value, unit: 'px' };
+        case 2 /* MasonLengthPercentageAutoCompatType.Percent */:
+            return { value: value, unit: '%' };
+    }
+}
+export function _toMasonDimension(value) {
+    if (value === undefined || value === null) {
+        return value;
+    }
+    if (value === 'auto') {
+        return { value: 0, type: 'auto', native_type: 0 /* MasonDimensionCompatType.Auto */ };
+    }
+    let typeOf = typeof value;
+    if (typeOf === 'number') {
+        return { value: Utils.layout.toDevicePixels(value), type: 'points', native_type: 1 /* MasonDimensionCompatType.Points */ };
+    }
+    if (typeOf === 'string') {
+        value = parseUnit(value).value;
+        typeOf = 'object';
+    }
+    if (typeOf === 'object') {
+        switch (value?.unit) {
+            case '%':
+                return { value: value.value, type: 'percent', native_type: 2 /* MasonDimensionCompatType.Percent */ };
+            case 'px':
+                return { value: value.value, type: 'points', native_type: 1 /* MasonDimensionCompatType.Points */ };
+            case 'dip':
+                return { value: Utils.layout.toDevicePixels(value.value), type: 'points', native_type: 1 /* MasonDimensionCompatType.Points */ };
+        }
+    }
+    return { value: value, type: 'points', native_type: 1 /* MasonDimensionCompatType.Points */ };
+}
+export function _intoMasonDimension(value) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    if (value === 'auto') {
+        return MasonDimensionCompat.Auto;
+    }
+    const typeOf = typeof value;
+    if (typeOf === 'object') {
+        switch (value?.unit) {
+            case '%':
+                return MasonDimensionCompat.alloc().initWithPercent(value.value);
+            case 'px':
+                return MasonDimensionCompat.alloc().initWithPoints(value.value);
+            case 'dip':
+                return MasonDimensionCompat.alloc().initWithPoints(Utils.layout.toDevicePixels(value.value));
+        }
+    }
+    if (typeOf === 'number') {
+        return MasonDimensionCompat.alloc().initWithPoints(Utils.layout.toDevicePixels(value));
+    }
+    return MasonDimensionCompat.alloc().initWithPoints(Utils.layout.toDevicePixels(value));
+}
+export function _toLengthPercentageAuto(value) {
+    if (value === undefined || value === null) {
+        return value;
+    }
+    if (value === 'auto') {
+        return { value: 0, type: 'auto', native_type: 0 /* MasonLengthPercentageAutoCompatType.Auto */ };
+    }
+    const typeOf = typeof value;
+    if (typeOf === 'object') {
+        switch (value?.unit) {
+            case '%':
+                return { value: value.value, type: 'percent', native_type: 2 /* MasonLengthPercentageAutoCompatType.Percent */ };
+            case 'px':
+                return { value: value.value, type: 'points', native_type: 1 /* MasonLengthPercentageAutoCompatType.Points */ };
+            case 'dip':
+                return { value: Utils.layout.toDevicePixels(value.value), type: 'points', native_type: 1 /* MasonLengthPercentageAutoCompatType.Points */ };
+        }
+    }
+    if (typeOf === 'number') {
+        return { value: Utils.layout.toDevicePixels(value), type: 'points', native_type: 1 /* MasonLengthPercentageAutoCompatType.Points */ };
+    }
+    return { value: value, type: 'points', native_type: 1 /* MasonLengthPercentageAutoCompatType.Points */ };
+}
+export function _toLengthPercentage(value) {
+    if (value === undefined || value === null) {
+        return value;
+    }
+    if (typeof value === 'string') {
+        const parsed = Length.parse(value);
+        if (parsed) {
+            value = parsed;
+        }
+    }
+    const typeOf = typeof value;
+    if (typeOf === 'object') {
+        switch (value?.unit) {
+            case '%':
+                return { value: value.value, type: 'percent', native_type: 1 /* MasonLengthPercentageCompatType.Percent */ };
+            case 'px':
+                return { value: value.value, type: 'points', native_type: 0 /* MasonLengthPercentageCompatType.Points */ };
+            case 'dip':
+                return { value: Utils.layout.toDevicePixels(value.value), type: 'points', native_type: 0 /* MasonLengthPercentageCompatType.Points */ };
+        }
+    }
+    if (typeOf === 'number') {
+        return { value: Utils.layout.toDevicePixels(value), type: 'points', native_type: 0 /* MasonLengthPercentageCompatType.Points */ };
+    }
+    return { value: value, type: 'points', native_type: 0 /* MasonLengthPercentageCompatType.Points */ };
+}
+function syncStyle(instance) {
+    // noop
+}
+export function _getAspectRatio(instance) {
+    if (!instance._hasNativeView) {
+        return instance.style.aspectRatio;
+    }
+    const ratio = instance._styleHelper.aspectRatio;
+    return Number.isNaN(ratio) ? null : ratio;
+}
+export function _parseGridLine(value) {
+    let parsedValue = undefined;
+    let parsedType = undefined;
+    if (value === 'auto' || value === undefined) {
+        parsedValue = 0;
+        parsedType = 0 /* GridPlacementCompatType.Auto */;
+    }
+    if (typeof value === 'string') {
+        if (value.startsWith('span')) {
+            parsedValue = Number(value.replace('span', '').trim());
+            parsedType = 2 /* GridPlacementCompatType.Span */;
+        }
+        else {
+            parsedValue = Number(value.trim());
+            if (parsedValue < 1) {
+                parsedValue = 0;
+                parsedType = 0 /* GridPlacementCompatType.Auto */;
+            }
+            else {
+                parsedType = 1 /* GridPlacementCompatType.Line */;
+            }
+        }
+    }
+    if (typeof value === 'number') {
+        parsedValue = value;
+        if (parsedValue < 1) {
+            parsedValue = 0;
+            parsedType = 0 /* GridPlacementCompatType.Auto */;
+        }
+        else {
+            parsedType = 1 /* GridPlacementCompatType.Line */;
+        }
+    }
+    return { value: Number.isNaN(parsedValue) ? undefined : parsedValue, type: parsedType };
+}
+export function _setGridColumnStart(value, instance, initial = false) {
+    if (!instance._hasNativeView) {
+        return;
+    }
+    const val = _parseGridLine(value);
+    if (val.value === undefined || val.type === undefined) {
+        return;
+    }
+    switch (val.type) {
+        case 0 /* GridPlacementCompatType.Auto */:
+            instance.ios.gridColumnStartCompat = GridPlacementCompat.Auto;
+            break;
+        case 1 /* GridPlacementCompatType.Line */:
+            instance.ios.gridColumnStartCompat = GridPlacementCompat.alloc().initWithLine(val.value);
+            break;
+        case 2 /* GridPlacementCompatType.Span */:
+            instance.ios.gridColumnStartCompat = GridPlacementCompat.alloc().initWithSpan(val.value);
+            break;
+    }
+}
+export function _setGridColumnEnd(value, instance, initial = false) {
+    if (!instance._hasNativeView) {
+        return;
+    }
+    const val = _parseGridLine(value);
+    if (val.value === undefined || val.type === undefined) {
+        return;
+    }
+    switch (val.type) {
+        case 0 /* GridPlacementCompatType.Auto */:
+            instance.ios.gridColumnEndCompat = GridPlacementCompat.Auto;
+            break;
+        case 1 /* GridPlacementCompatType.Line */:
+            instance.ios.gridColumnEndCompat = GridPlacementCompat.alloc().initWithLine(val.value);
+            break;
+        case 2 /* GridPlacementCompatType.Span */:
+            instance.ios.gridColumnEndCompat = GridPlacementCompat.alloc().initWithSpan(val.value);
+            break;
+    }
+}
+export function _setGridRowStart(value, instance, initial = false) {
+    if (!instance._hasNativeView) {
+        return;
+    }
+    const val = _parseGridLine(value);
+    if (val.value === undefined || val.type === undefined) {
+        return;
+    }
+    switch (val.type) {
+        case 0 /* GridPlacementCompatType.Auto */:
+            instance.ios.gridRowStartCompat = GridPlacementCompat.Auto;
+            break;
+        case 1 /* GridPlacementCompatType.Line */:
+            instance.ios.gridRowStartCompat = GridPlacementCompat.alloc().initWithLine(val.value);
+            break;
+        case 2 /* GridPlacementCompatType.Span */:
+            instance.ios.gridRowStartCompat = GridPlacementCompat.alloc().initWithSpan(val.value);
+            break;
+    }
+}
+export function _setGridRowEnd(value, instance, initial = false) {
+    if (!instance._hasNativeView) {
+        return;
+    }
+    const val = _parseGridLine(value);
+    if (val.value === undefined || val.type === undefined) {
+        return;
+    }
+    switch (val.type) {
+        case 0 /* GridPlacementCompatType.Auto */:
+            instance.ios.gridRowEndCompat = GridPlacementCompat.Auto;
+            break;
+        case 1 /* GridPlacementCompatType.Line */:
+            instance.ios.gridRowEndCompat = GridPlacementCompat.alloc().initWithLine(val.value);
+            break;
+        case 2 /* GridPlacementCompatType.Span */:
+            instance.ios.gridRowEndCompat = GridPlacementCompat.alloc().initWithSpan(val.value);
+            break;
+    }
+}
+export function _setRowGap(value, instance, initial = false) {
+    if (!instance._hasNativeView) {
+        return;
+    }
+    instance._styleHelper.rowGap = value;
+}
+export function _getRowGap(instance) {
+    if (!instance._hasNativeView) {
+        return instance.style.rowGap;
+    }
+    return instance._styleHelper.rowGap;
+}
+export function _setColumnGap(value, instance, initial = false) {
+    if (!instance._hasNativeView) {
+        return;
+    }
+    instance._styleHelper.columnGap = value;
+}
+export function _getColumnGap(instance) {
+    if (!instance._hasNativeView) {
+        return instance.style.gap;
+    }
+    return instance._styleHelper.columnGap;
+}
+const Auto = 'auto';
+const None = 'none';
+const MinContent = 'min-content';
+const MaxContent = 'max-content';
+export function _parseMinMaxValue(value) {
+    if (typeof value === 'string') {
+        if (value === Auto || value === None) {
+            return {
+                min_type: 0 /* MinSizingType.Auto */,
+                min_value: 0,
+                max_type: 0 /* MaxSizingType.Auto */,
+                max_value: 0,
+            };
+        }
+        else if (value === MinContent) {
+            return {
+                min_type: 1 /* MinSizingType.MinContent */,
+                min_value: 0,
+                max_type: 1 /* MaxSizingType.MinContent */,
+                max_value: 0,
+            };
+        }
+        else if (value === MaxContent) {
+            return {
+                min_type: 2 /* MinSizingType.MaxContent */,
+                min_value: 0,
+                max_type: 2 /* MaxSizingType.MaxContent */,
+                max_value: 0,
+            };
+        }
+        else if (value.indexOf('fr') > -1) {
+            const flex = parseInt(value.replace('fr', '').trim());
+            return {
+                min_type: 0 /* MinSizingType.Auto */,
+                min_value: 0,
+                max_type: 5 /* MaxSizingType.Fraction */,
+                max_value: flex,
+            };
+        }
+        else if (value.startsWith('minmax')) {
+            // todo
+            const minMax = parseInt(value.replace('minmax(', '').replace(')', '').trim());
+        }
+        else if (value.startsWith('fit-content')) {
+            const fitContent = value.replace('fit-content(', '').replace(')', '').trim();
+            if (fitContent.indexOf('px') > -1) {
+                const px = parseInt(fitContent.replace('px', ''));
+                return {
+                    min_type: 0 /* MinSizingType.Auto */,
+                    min_value: px,
+                    max_type: 6 /* MaxSizingType.FitContent */,
+                    max_value: px,
+                };
+            }
+            if (fitContent.indexOf('px') > -1) {
+                const dip = Utils.layout.toDevicePixels(parseInt(fitContent.replace('dip', '')));
+                return {
+                    min_type: 0 /* MinSizingType.Auto */,
+                    min_value: dip,
+                    max_type: 6 /* MaxSizingType.FitContent */,
+                    max_value: dip,
+                };
+            }
+            if (fitContent.indexOf('%') > -1) {
+                const percent = parseFloat(fitContent.replace('%', ''));
+                return {
+                    min_type: 0 /* MinSizingType.Auto */,
+                    min_value: percent,
+                    max_type: 7 /* MaxSizingType.FitContentPercent */,
+                    max_value: percent,
+                };
+            }
+        }
+        else if (value.indexOf('px') > -1) {
+            const px = parseInt(value.replace('px', ''));
+            return {
+                min_type: 3 /* MinSizingType.Points */,
+                min_value: px,
+                max_type: 3 /* MaxSizingType.Points */,
+                max_value: px,
+            };
+        }
+        else if (value.indexOf('dip') > -1) {
+            const dip = Utils.layout.toDevicePixels(parseInt(value.replace('dip', '')));
+            return {
+                min_type: 3 /* MinSizingType.Points */,
+                min_value: dip,
+                max_type: 3 /* MaxSizingType.Points */,
+                max_value: dip,
+            };
+        }
+        else if (value.indexOf('%') > -1) {
+            const percent = parseFloat(value.replace('%', ''));
+            return {
+                min_type: 4 /* MinSizingType.Percent */,
+                min_value: percent,
+                max_type: 4 /* MaxSizingType.Percent */,
+                max_value: percent,
+            };
+        }
+        else {
+            const dip = Utils.layout.toDevicePixels(Number(value));
+            return {
+                min_type: 3 /* MinSizingType.Points */,
+                min_value: dip,
+                max_type: 3 /* MaxSizingType.Points */,
+                max_value: dip,
+            };
+        }
+    }
+    if (typeof value === 'number') {
+        const dip = Utils.layout.toDevicePixels(value);
+        return {
+            min_type: 3 /* MinSizingType.Points */,
+            min_value: dip,
+            max_type: 3 /* MaxSizingType.Points */,
+            max_value: dip,
+        };
+    }
+    return undefined;
+}
+const grid_templates_regex = /[^\s()]+(?:\([^\s()]+(?:\([^()]+\))?(?:, *[^\s()]+(?:\([^()]+\))?)*\))?/g;
+export function _parseGridTemplates(value) {
+    const array = [];
+    if (typeof value === 'string') {
+        const values = Array.from(value.matchAll(grid_templates_regex), (m) => m[0]);
+        values.forEach((item) => {
+            if (item.startsWith('repeat(')) {
+                const repeatValue = item.replace('repeat(', '').replace(')', '');
+                const trackEnd = repeatValue.indexOf(',');
+                const repetition = repeatValue.substring(0, trackEnd);
+                const tracks = repeatValue
+                    .substring(trackEnd + 1)
+                    .split(' ')
+                    .filter((a) => {
+                    return a.length || a.trim() === ',';
+                });
+                let isValid = true;
+                let repeating_type = 0;
+                let repeat_count = 0;
+                switch (repetition) {
+                    case 'repeat-fill':
+                        repeating_type = 0 /* TSCGridTrackRepetition.AutoFill */;
+                        break;
+                    case 'repeat-fit':
+                        repeating_type = 1 /* TSCGridTrackRepetition.AutoFit */;
+                        break;
+                    default:
+                        {
+                            const number = parseInt(repetition);
+                            repeating_type = 2 /* TSCGridTrackRepetition.Count */;
+                            isValid = !Number.isNaN(number);
+                            if (isValid) {
+                                repeat_count = number;
+                            }
+                        }
+                        break;
+                }
+                if (isValid) {
+                    const tracks_array = [];
+                    tracks.forEach((track) => {
+                        const minMax = _parseMinMaxValue(track.trim());
+                        tracks_array.push(minMax);
+                    });
+                    array.push({
+                        is_repeating: true,
+                        repeating_type,
+                        repeating_count: repeat_count,
+                        value: tracks_array,
+                    });
+                }
+            }
+            else {
+                const value = _parseMinMaxValue(item);
+                array.push({
+                    is_repeating: false,
+                    repeating_type: 0,
+                    value,
+                });
+            }
+        });
+    }
+    return array;
+}
+export function _setGridTemplateRows(value, instance, initial = false) {
+    if (!instance[isMasonView_]) {
+        return;
+    }
+    const length = value.length;
+    const array = NSMutableArray.arrayWithCapacity(length);
+    for (let i = 0; i < length; i++) {
+        const item = value[i];
+        if (item.is_repeating) {
+            const repeating = item.value;
+            const repeatingLength = repeating.length;
+            const tracks = NSMutableArray.arrayWithCapacity(repeatingLength);
+            let gridTrackRepetition = null;
+            switch (item.repeating_type) {
+                case 0 /* TSCGridTrackRepetition.AutoFill */:
+                    gridTrackRepetition = MasonGridTrackRepetition.AutoFill;
+                    break;
+                case 1 /* TSCGridTrackRepetition.AutoFit */:
+                    gridTrackRepetition = MasonGridTrackRepetition.AutoFit;
+                    break;
+                case 2 /* TSCGridTrackRepetition.Count */:
+                    gridTrackRepetition = MasonGridTrackRepetition.Count(item.repeating_count);
+                    break;
+            }
+            if (gridTrackRepetition === null) {
+                continue;
+            }
+            for (let j = 0; j < repeatingLength; j++) {
+                const repeat = repeating[j];
+                tracks.addObject(MinMax.fromTypeValue(repeat.min_type, repeat.min_value, repeat.max_type, repeat.max_value));
+            }
+            const repeat = TrackSizingFunction.AutoRepeat(gridTrackRepetition, tracks);
+            array.addObject(repeat);
+        }
+        else {
+            const single = item.value;
+            const trackSizingFunction = TrackSizingFunction.Single(MinMax.fromTypeValue(single.min_type, single.min_value, single.max_type, single.max_value));
+            array.addObject(trackSizingFunction);
+        }
+    }
+    instance.ios.gridTemplateRows = array;
+}
+export function _setGridTemplateColumns(value, instance, initial = false) {
+    if (!instance[isMasonView_]) {
+        return;
+    }
+    const length = value.length;
+    const array = NSMutableArray.new();
+    for (let i = 0; i < length; i++) {
+        const item = value[i];
+        if (item.is_repeating) {
+            const repeating = item.value;
+            const repeatingLength = repeating.length;
+            const tracks = NSMutableArray.arrayWithCapacity(repeatingLength);
+            let gridTrackRepetition = null;
+            switch (item.repeating_type) {
+                case 0 /* TSCGridTrackRepetition.AutoFill */:
+                    gridTrackRepetition = 0 /* TSCGridTrackRepetition.AutoFill */;
+                    break;
+                case 1 /* TSCGridTrackRepetition.AutoFit */:
+                    gridTrackRepetition = 1 /* TSCGridTrackRepetition.AutoFit */;
+                    break;
+                case 2 /* TSCGridTrackRepetition.Count */:
+                    gridTrackRepetition = MasonGridTrackRepetition.Count(item.repeating_count);
+                    break;
+            }
+            if (gridTrackRepetition === null) {
+                continue;
+            }
+            for (let j = 0; j < repeatingLength; j++) {
+                const repeat = repeating[j];
+                tracks.addObject(MinMax.fromTypeValue(repeat.min_type, repeat.min_value, repeat.max_type, repeat.max_value));
+            }
+            const repeat = TrackSizingFunction.AutoRepeat(gridTrackRepetition, tracks);
+            array.addObject(repeat);
+        }
+        else {
+            const single = item.value;
+            const trackSizingFunction = TrackSizingFunction.Single(MinMax.fromTypeValue(single.min_type, single.min_value, single.max_type, single.max_value));
+            array.addObject(trackSizingFunction);
+        }
+    }
+    instance.ios.gridTemplateColumns = array;
+}
+export function _parseGridAutoRowsColumns(value) {
+    const array = [];
+    if (typeof value === 'string') {
+        const values = value.split(' ');
+        values.forEach((item) => {
+            const value = _parseMinMaxValue(item);
+            array.push({
+                is_repeating: false,
+                repeating_type: 0,
+                value,
+            });
+        });
+    }
+    return array;
+}
+export function _setGridAutoFlow(value, instance) {
+    if (!instance[isMasonView_]) {
+        return;
+    }
+    instance.ios.gridAutoFlow = value;
+}
+export function _getGridAutoFlow(instance) {
+    if (!instance[isMasonView_]) {
+        return;
+    }
+    return this._styleHelper.gridAutoFlow;
+}
+export function _setGridAutoRows(value, instance, initial = false) {
+    if (!instance[isMasonView_]) {
+        return;
+    }
+    const values = _parseGridAutoRowsColumns(value);
+    const length = value.length;
+    const array = NSMutableArray.arrayWithCapacity(length);
+    for (let i = 0; i < length; i++) {
+        const item = value[i];
+        const minMax = MinMax.fromTypeValue(item.min_type, item.min_value, item.max_type, item.max_value);
+        array.addObject(minMax);
+    }
+    instance.ios.gridAutoRows = array;
+}
+export function _setGridAutoColumns(value, instance, initial = false) {
+    if (!instance[isMasonView_]) {
+        return;
+    }
+    const values = _parseGridAutoRowsColumns(value);
+    const length = value.length;
+    const array = NSMutableArray.arrayWithCapacity(length);
+    for (let i = 0; i < length; i++) {
+        const item = values[i];
+        const minMax = MinMax.fromTypeValue(item.min_type, item.min_value, item.max_type, item.max_value);
+        array.addObject(minMax);
+    }
+    instance.ios.gridAutoColumns = array;
+}
+export function _getGridTemplateRows(instance) {
+    if (!instance[isMasonView_]) {
+        return '';
+    }
+    return ''; //instance.ios.style.gridTemplateRowsCSS;
+}
+export function _getGridTemplateColumns(instance) {
+    if (!instance[isMasonView_]) {
+        return '';
+    }
+    return ''; //instance.ios.style.gridTemplateColumnsCSS;
+}
+//# sourceMappingURL=index.ios.js.map