@triniwiz/nativescript-masonkit 1.0.0-alpha.28 → 1.0.0-alpha.30

package/utils/index.ios.js

@@ -1,710 +0,0 @@
-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