@octane-xplat/nativescript-mason-core 0.0.1 → 1.0.0-beta.0

package/utils/index.android.js

@@ -0,0 +1,595 @@
+// declare const __non_webpack_require__;
+import { Length } from '@nativescript/core';
+import { parseUnit } from '@nativescript/core/css/parser';
+import { Tree } from '../tree';
+import { isMasonView_, style_ } from '../symbols';
+import { masonLayout } from '../display-density';
+export function parseLength(length, parent = 0) {
+    switch (length.unit) {
+        case '%':
+            return length.value * parent;
+        case 'dip':
+            return masonLayout.toDevicePixels(length.value);
+        case 'px':
+            return masonLayout.toDevicePixels(length.value);
+    }
+}
+let sharedMason = null;
+function getMasonInstance(instance) {
+    const nativeView = instance?.android;
+    if (instance[isMasonView_]) {
+        return nativeView.getNode();
+    }
+    if (!sharedMason) {
+        sharedMason = org.nativescript.mason.masonkit.Mason.getShared();
+    }
+    return sharedMason.nodeForView(nativeView);
+}
+function getStyleInstance(instance) {
+    const nativeView = instance?.android;
+    if (instance[isMasonView_]) {
+        return nativeView.getStyle();
+    }
+    if (!sharedMason) {
+        sharedMason = org.nativescript.mason.masonkit.Mason.getShared();
+    }
+    return sharedMason.nodeForView(nativeView).getStyle();
+}
+export function _forceStyleUpdate(instance) {
+    if (!instance[isMasonView_]) {
+        return;
+    }
+    if (instance[isMasonView_]) {
+    }
+    //   const nodeOrView = getMasonInstance(instance) as org.nativescript.mason.masonkit.TextView;
+    //   nodeOrView.getStyle().updateNodeAndStyle();
+}
+export function _markDirty(instance) {
+    if (!instance[isMasonView_]) {
+        return;
+    }
+    const nodeOrView = getMasonInstance(instance);
+    nodeOrView.dirty();
+}
+export function _isDirty(instance) {
+    if (!instance[isMasonView_]) {
+        return;
+    }
+    const nodeOrView = getMasonInstance(instance);
+    return nodeOrView.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 */;
+        case 'min-content':
+            return 3 /* MasonDimensionCompatType.MinContent */;
+        case 'max-content':
+            return 4 /* MasonDimensionCompatType.MaxContent */;
+        case 'fit-content':
+            return 5 /* MasonDimensionCompatType.FitContent */;
+        case 'fit-content-points':
+            return 6 /* MasonDimensionCompatType.FitContentPoints */;
+        case 'fit-content-percent':
+            return 7 /* MasonDimensionCompatType.FitContentPercent */;
+        case 'stretch':
+            return 8 /* MasonDimensionCompatType.Stretch */;
+        case 'content':
+            return 9 /* MasonDimensionCompatType.Content */;
+        default:
+            return 0 /* MasonDimensionCompatType.Auto */;
+    }
+}
+export function _parseDimension(dim) {
+    const name = dim.getClass().getName();
+    switch (name) {
+        case 'org.nativescript.mason.masonkit.Dimension$Points':
+            return { value: dim.getPoints(), unit: 'px' };
+        case 'org.nativescript.mason.masonkit.Dimension$Percent':
+            return { value: dim.getPercentage(), unit: '%' };
+        case 'org.nativescript.mason.masonkit.Dimension$Auto':
+            return 'auto';
+        case 'org.nativescript.mason.masonkit.Dimension$MinContent':
+            return 'min-content';
+        case 'org.nativescript.mason.masonkit.Dimension$MaxContent':
+            return 'max-content';
+        case 'org.nativescript.mason.masonkit.Dimension$FitContent':
+            return 'fit-content';
+        case 'org.nativescript.mason.masonkit.Dimension$FitContentPoints':
+            return `fit-content(${dim.getPoints()}px)`;
+        case 'org.nativescript.mason.masonkit.Dimension$FitContentPercent':
+            return `fit-content(${dim.getPercentage()}%)`;
+        case 'org.nativescript.mason.masonkit.Dimension$Stretch':
+            return 'stretch';
+        case 'org.nativescript.mason.masonkit.Dimension$Content':
+            return 'content';
+    }
+}
+export function _parseLengthPercentage(dim) {
+    const name = dim.getClass().getName();
+    switch (name) {
+        case 'org.nativescript.mason.masonkit.LengthPercentage$Points':
+            return { value: dim.getPoints(), unit: 'px' };
+        case 'org.nativescript.mason.masonkit.LengthPercentage$Percent':
+            return { value: dim.getPercentage(), unit: '%' };
+        case 'org.nativescript.mason.masonkit.LengthPercentage$Auto':
+            return 'auto';
+    }
+}
+export function _parseLengthPercentageAuto(dim) {
+    const name = dim.getClass().getName();
+    switch (name) {
+        case 'org.nativescript.mason.masonkit.LengthPercentageAuto$Points':
+            return { value: dim.getPoints(), unit: 'px' };
+        case 'org.nativescript.mason.masonkit.LengthPercentageAuto$Percent':
+            return { value: dim.getPercentage(), unit: '%' };
+        case 'org.nativescript.mason.masonkit.LengthPercentageAuto$Auto':
+            return 'auto';
+    }
+}
+export function _toMasonDimension(value) {
+    if (value === undefined || value === null) {
+        return value;
+    }
+    if (value === 'auto') {
+        return { value: 0, type: 'auto', native_type: 0 /* MasonDimensionCompatType.Auto */ };
+    }
+    if (typeof value === 'string') {
+        const parsed = _parseDimensionString(value);
+        if (parsed) {
+            return parsed;
+        }
+    }
+    let typeOf = typeof value;
+    if (typeOf === 'number') {
+        return { value: masonLayout.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: masonLayout.toDevicePixels(value.value), type: 'points', native_type: 1 /* MasonDimensionCompatType.Points */ };
+            case 'dip':
+                return { value: masonLayout.toDevicePixels(value.value), type: 'points', native_type: 1 /* MasonDimensionCompatType.Points */ };
+        }
+    }
+    return { value: value, type: 'points', native_type: 1 /* MasonDimensionCompatType.Points */ };
+}
+function _parseDimensionString(value) {
+    const t = value.trim();
+    switch (t) {
+        case 'auto':
+            return { value: 0, type: 'auto', native_type: 0 /* MasonDimensionCompatType.Auto */ };
+        case 'min-content':
+            return { value: 0, type: 'min-content', native_type: 3 /* MasonDimensionCompatType.MinContent */ };
+        case 'max-content':
+            return { value: 0, type: 'max-content', native_type: 4 /* MasonDimensionCompatType.MaxContent */ };
+        case 'fit-content':
+            return { value: 0, type: 'fit-content', native_type: 5 /* MasonDimensionCompatType.FitContent */ };
+        case 'stretch':
+            return { value: 0, type: 'stretch', native_type: 8 /* MasonDimensionCompatType.Stretch */ };
+        case 'content':
+            return { value: 0, type: 'content', native_type: 9 /* MasonDimensionCompatType.Content */ };
+    }
+    if (t.startsWith('fit-content(') && t.endsWith(')')) {
+        const limit = t.slice('fit-content('.length, -1).trim();
+        if (limit.endsWith('%')) {
+            return { value: parseFloat(limit) || 0, type: 'fit-content-percent', native_type: 7 /* MasonDimensionCompatType.FitContentPercent */ };
+        }
+        const n = parseFloat(limit) || 0;
+        return { value: limit.endsWith('px') ? n : masonLayout.toDevicePixels(n), type: 'fit-content-points', native_type: 6 /* MasonDimensionCompatType.FitContentPoints */ };
+    }
+    return null;
+}
+export function _intoMasonDimension(value) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    if (typeof value === 'string') {
+        const parsed = _parseDimensionString(value);
+        if (parsed) {
+            const Dimension = org.nativescript.mason.masonkit.Dimension;
+            switch (parsed.native_type) {
+                case 0 /* MasonDimensionCompatType.Auto */:
+                    return Dimension.Auto;
+                case 3 /* MasonDimensionCompatType.MinContent */:
+                    return Dimension.MinContent;
+                case 4 /* MasonDimensionCompatType.MaxContent */:
+                    return Dimension.MaxContent;
+                case 5 /* MasonDimensionCompatType.FitContent */:
+                    return Dimension.FitContent;
+                case 6 /* MasonDimensionCompatType.FitContentPoints */:
+                    return new Dimension.FitContentPoints(parsed.value);
+                case 7 /* MasonDimensionCompatType.FitContentPercent */:
+                    return new Dimension.FitContentPercent(parsed.value);
+                case 8 /* MasonDimensionCompatType.Stretch */:
+                    return Dimension.Stretch;
+                case 9 /* MasonDimensionCompatType.Content */:
+                    return Dimension.Content;
+            }
+        }
+    }
+    const typeOf = typeof value;
+    if (typeOf === 'object') {
+        switch (value?.unit) {
+            case '%':
+                return new org.nativescript.mason.masonkit.Dimension.Percent(value.value);
+            case 'px':
+                return new org.nativescript.mason.masonkit.Dimension.Points(masonLayout.toDevicePixels(value.value));
+            case 'dip':
+                return new org.nativescript.mason.masonkit.Dimension.Points(masonLayout.toDevicePixels(value.value));
+        }
+    }
+    if (typeOf === 'number') {
+        return new org.nativescript.mason.masonkit.Dimension.Points(masonLayout.toDevicePixels(value));
+    }
+    return new org.nativescript.mason.masonkit.Dimension.Points(masonLayout.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: masonLayout.toDevicePixels(value.value), type: 'points', native_type: 1 /* MasonLengthPercentageAutoCompatType.Points */ };
+            case 'dip':
+                return { value: masonLayout.toDevicePixels(value.value), type: 'points', native_type: 1 /* MasonLengthPercentageAutoCompatType.Points */ };
+        }
+    }
+    if (typeOf === 'number') {
+        return { value: masonLayout.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: masonLayout.toDevicePixels(value.value), type: 'points', native_type: 0 /* MasonLengthPercentageCompatType.Points */ };
+            case 'dip':
+                return { value: masonLayout.toDevicePixels(value.value), type: 'points', native_type: 0 /* MasonLengthPercentageCompatType.Points */ };
+        }
+    }
+    if (typeOf === 'number') {
+        return { value: masonLayout.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 _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 };
+}
+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 = masonLayout.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 = masonLayout.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 = masonLayout.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 = masonLayout.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;
+    }
+}
+export function _setGridTemplateColumns(value, instance, initial = false) { }
+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 _setGridAutoRows(value, instance, initial = false) {
+    if (!instance[isMasonView_]) {
+        return;
+    }
+    const values = _parseGridAutoRowsColumns(value);
+    const array = Array.create('org.nativescript.mason.masonkit.MinMax', values.length);
+    const length = array.length;
+    for (let i = 0; i < length; i++) {
+        const item = value[i];
+        const minMax = org.nativescript.mason.masonkit.MinMax.fromTypeValue(item.min_type, item.min_value, item.max_type, item.max_value);
+        array[i] = minMax;
+    }
+    if (instance.android?.setGridAutoRows) {
+        instance.android.setGridAutoRows(array);
+    }
+    else {
+        const style = org.nativescript.mason.masonkit.Mason.getShared().styleForView(instance.android);
+        if (style) {
+            style.setGridAutoRows(array);
+        }
+    }
+}
+export function _setGridAutoColumns(value, instance, initial = false) {
+    if (!instance[isMasonView_]) {
+        return;
+    }
+    const values = _parseGridAutoRowsColumns(value);
+    const array = Array.create('org.nativescript.mason.masonkit.MinMax', values.length);
+    const length = value.length;
+    for (let i = 0; i < length; i++) {
+        const item = value[i];
+        const minMax = org.nativescript.mason.masonkit.MinMax.fromTypeValue(item.min_type, item.min_value, item.max_type, item.max_value);
+        array[i] = minMax;
+    }
+    if (instance.android?.setGridAutoColumns) {
+        instance.android.setGridAutoColumns(array);
+    }
+    else {
+        const style = org.nativescript.mason.masonkit.Mason.getShared().styleForView(instance.android);
+        if (style) {
+            style.setGridAutoColumns(array);
+        }
+    }
+}
+export function _getGridTemplateRows(instance) {
+    if (!instance[isMasonView_]) {
+        return '';
+    }
+    if (__ANDROID__) {
+        return org.nativescript.mason.masonkit.StyleHelpers.gridTemplateRowsCSS(Tree.instance.native, instance.android);
+    }
+    const style = org.nativescript.mason.masonkit.Mason.getShared().styleForView(instance.android);
+    if (style) {
+        return style.getGridTemplateRows();
+    }
+    return [];
+}
+export function _getGridTemplateColumns(instance) {
+    if (!instance[isMasonView_]) {
+        return [];
+    }
+    const style = org.nativescript.mason.masonkit.Mason.getShared().styleForView(instance.android);
+    if (style) {
+        return style.getGridTemplateColumns();
+    }
+    return [];
+}