@ohos-ports/html2canvas-pro 0.0.0-stage → 2.3.2-beta.0

package/dist/lib/css/types/image.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.image = exports.isRepeatingLinearGradient = exports.isRadialGradient = exports.isLinearGradient = void 0;
+exports.isSupportedImage = isSupportedImage;
+const linear_gradient_1 = require("./functions/linear-gradient");
+const _prefix_linear_gradient_1 = require("./functions/-prefix-linear-gradient");
+const _webkit_gradient_1 = require("./functions/-webkit-gradient");
+const radial_gradient_1 = require("./functions/radial-gradient");
+const _prefix_radial_gradient_1 = require("./functions/-prefix-radial-gradient");
+const repeating_linear_gradient_1 = require("./functions/repeating-linear-gradient");
+const isLinearGradient = (background) => {
+    return background.type === 1 /* CSSImageType.LINEAR_GRADIENT */;
+};
+exports.isLinearGradient = isLinearGradient;
+const isRadialGradient = (background) => {
+    return background.type === 2 /* CSSImageType.RADIAL_GRADIENT */;
+};
+exports.isRadialGradient = isRadialGradient;
+const isRepeatingLinearGradient = (background) => {
+    return background.type === 3 /* CSSImageType.REPEATING_LINEAR_GRADIENT */;
+};
+exports.isRepeatingLinearGradient = isRepeatingLinearGradient;
+exports.image = {
+    name: 'image',
+    parse: (context, value) => {
+        if (value.type === 22 /* TokenType.URL_TOKEN */) {
+            const image = { url: value.value, type: 0 /* CSSImageType.URL */ };
+            context.cache.addImage(value.value);
+            return image;
+        }
+        if (value.type === 18 /* TokenType.FUNCTION */) {
+            const imageFunction = SUPPORTED_IMAGE_FUNCTIONS[value.name];
+            if (typeof imageFunction === 'undefined') {
+                throw new Error(`Attempting to parse an unsupported image function "${value.name}"`);
+            }
+            return imageFunction(context, value.values);
+        }
+        throw new Error(`Unsupported image type ${value.type}`);
+    }
+};
+function isSupportedImage(value) {
+    return (!(value.type === 20 /* TokenType.IDENT_TOKEN */ && value.value === 'none') &&
+        (value.type !== 18 /* TokenType.FUNCTION */ || !!SUPPORTED_IMAGE_FUNCTIONS[value.name]));
+}
+const SUPPORTED_IMAGE_FUNCTIONS = {
+    'linear-gradient': linear_gradient_1.linearGradient,
+    '-moz-linear-gradient': _prefix_linear_gradient_1.prefixLinearGradient,
+    '-ms-linear-gradient': _prefix_linear_gradient_1.prefixLinearGradient,
+    '-o-linear-gradient': _prefix_linear_gradient_1.prefixLinearGradient,
+    '-webkit-linear-gradient': _prefix_linear_gradient_1.prefixLinearGradient,
+    'radial-gradient': radial_gradient_1.radialGradient,
+    '-moz-radial-gradient': _prefix_radial_gradient_1.prefixRadialGradient,
+    '-ms-radial-gradient': _prefix_radial_gradient_1.prefixRadialGradient,
+    '-o-radial-gradient': _prefix_radial_gradient_1.prefixRadialGradient,
+    '-webkit-radial-gradient': _prefix_radial_gradient_1.prefixRadialGradient,
+    '-webkit-gradient': _webkit_gradient_1.webkitGradient,
+    'repeating-linear-gradient': repeating_linear_gradient_1.repeatingLinearGradient,
+    '-webkit-repeating-linear-gradient': repeating_linear_gradient_1.repeatingLinearGradient,
+    '-moz-repeating-linear-gradient': repeating_linear_gradient_1.repeatingLinearGradient,
+    '-ms-repeating-linear-gradient': repeating_linear_gradient_1.repeatingLinearGradient,
+    '-o-repeating-linear-gradient': repeating_linear_gradient_1.repeatingLinearGradient
+};

package/dist/lib/css/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/css/types/length-percentage.js

@@ -0,0 +1,197 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAbsoluteValue = exports.getAbsoluteValueForTuple = exports.HUNDRED_PERCENT = exports.FIFTY_PERCENT = exports.ZERO_LENGTH = exports.parseLengthPercentageTuple = exports.evaluateCalcToLengthPercentage = exports.parseOptionalCalcOrLength = exports.parseCalcForLengthPercentage = exports.isCalcFunction = exports.isCalcWithPercentage = exports.isLengthPercentage = void 0;
+const tokenizer_1 = require("../syntax/tokenizer");
+const parser_1 = require("../syntax/parser");
+const length_1 = require("./length");
+const safe_eval_1 = __importDefault(require("./safe-eval"));
+const isLengthPercentage = (token) => token.type === 16 /* TokenType.PERCENTAGE_TOKEN */ || (0, length_1.isLength)(token) || (0, exports.isCalcWithPercentage)(token);
+exports.isLengthPercentage = isLengthPercentage;
+/**
+ * Check if a token is a CalcWithPercentage deferred token.
+ * Accepts CSSValue (structural duck-type check) for use in type guards.
+ */
+const isCalcWithPercentage = (token) => token.type === 17 /* TokenType.NUMBER_TOKEN */ && token._calcPercentage !== undefined;
+exports.isCalcWithPercentage = isCalcWithPercentage;
+/**
+ * Check if a token is a calc() function
+ */
+const isCalcFunction = (token) => token.type === 18 /* TokenType.FUNCTION */ && token.name === 'calc';
+exports.isCalcFunction = isCalcFunction;
+/**
+ * Parse a calc() token and produce a LengthPercentage.
+ *
+ * Uses two-point evaluation to extract the percentage coefficient and pixel
+ * offset from a calc() expression so it can be resolved later at render time
+ * when the container size is known.
+ *
+ *   evaluate(0)   → pixelOffset
+ *   evaluate(100) → percentage + pixelOffset   →  percentage = evaluate(100) - pixelOffset
+ *
+ * If the expression has no percentage component, returns a plain NUMBER_TOKEN
+ * for backwards compatibility.
+ */
+const parseCalcForLengthPercentage = (calcToken) => {
+    const withZero = (0, exports.evaluateCalcToLengthPercentage)(calcToken, 0);
+    if (!withZero)
+        return null;
+    const withHundred = (0, exports.evaluateCalcToLengthPercentage)(calcToken, 100);
+    if (!withHundred)
+        return null;
+    const pixelOffset = withZero.number;
+    const percentage = withHundred.number - pixelOffset;
+    // If there's no percentage component, return a plain NUMBER_TOKEN
+    if (percentage === 0) {
+        return withZero;
+    }
+    return {
+        type: 17 /* TokenType.NUMBER_TOKEN */,
+        number: pixelOffset,
+        flags: tokenizer_1.FLAG_INTEGER,
+        _calcPercentage: percentage,
+        _calcPixelOffset: pixelOffset
+    };
+};
+exports.parseCalcForLengthPercentage = parseCalcForLengthPercentage;
+/**
+ * Convenience helper for parsing an optional calc() or length-percentage value.
+ * Used by property descriptors that accept both calc() and regular length-percentage tokens.
+ * Returns null if the value is neither a calc() function nor a length-percentage token.
+ */
+const parseOptionalCalcOrLength = (value) => {
+    if ((0, exports.isCalcFunction)(value)) {
+        return (0, exports.parseCalcForLengthPercentage)(value);
+    }
+    return (0, exports.isLengthPercentage)(value) ? value : null;
+};
+exports.parseOptionalCalcOrLength = parseOptionalCalcOrLength;
+/**
+ * Evaluate a calc() expression and convert to LengthPercentage token
+ * Supports basic arithmetic: +, -, *, /
+ * Note: Percentages in calc() are converted based on a context value
+ */
+const evaluateCalcToLengthPercentage = (calcToken, contextValue = 0) => {
+    // Build expression string from tokens
+    const buildExpression = (values) => {
+        let expression = '';
+        for (const value of values) {
+            if (value.type === 31 /* TokenType.WHITESPACE_TOKEN */) {
+                continue;
+            }
+            if (value.type === 18 /* TokenType.FUNCTION */) {
+                if (value.name === 'calc') {
+                    const nested = buildExpression(value.values);
+                    if (nested === null)
+                        return null;
+                    expression += `(${nested})`;
+                }
+                else {
+                    return null;
+                }
+            }
+            else if (value.type === 17 /* TokenType.NUMBER_TOKEN */) {
+                expression += value.number.toString();
+            }
+            else if (value.type === 15 /* TokenType.DIMENSION_TOKEN */) {
+                // Convert units to px
+                if (value.unit === 'px') {
+                    expression += value.number.toString();
+                }
+                else if (value.unit === 'rem' || value.unit === 'em') {
+                    expression += (value.number * 16).toString();
+                }
+                else {
+                    expression += value.number.toString();
+                }
+            }
+            else if (value.type === 16 /* TokenType.PERCENTAGE_TOKEN */) {
+                // Convert percentage to absolute value based on context
+                expression += ((value.number / 100) * contextValue).toString();
+            }
+            else if (value.type === 6 /* TokenType.DELIM_TOKEN */) {
+                const op = value.value;
+                if (op === '+' || op === '-' || op === '*' || op === '/') {
+                    expression += ` ${op} `;
+                }
+                else if (op === '(') {
+                    expression += '(';
+                }
+                else if (op === ')') {
+                    expression += ')';
+                }
+            }
+        }
+        return expression;
+    };
+    try {
+        const expression = buildExpression(calcToken.values);
+        if (expression === null || expression.trim() === '') {
+            return null;
+        }
+        // Evaluate the expression
+        // Uses safe arithmetic evaluator instead of new Function() for CodeQL
+        const result = (0, safe_eval_1.default)(expression);
+        if (typeof result === 'number' && !isNaN(result)) {
+            // Return as a number token in px
+            return {
+                type: 17 /* TokenType.NUMBER_TOKEN */,
+                number: result,
+                flags: tokenizer_1.FLAG_INTEGER
+            };
+        }
+    }
+    catch (e) {
+        return null;
+    }
+    return null;
+};
+exports.evaluateCalcToLengthPercentage = evaluateCalcToLengthPercentage;
+const parseLengthPercentageTuple = (tokens) => tokens.length > 1 ? [tokens[0], tokens[1]] : [tokens[0]];
+exports.parseLengthPercentageTuple = parseLengthPercentageTuple;
+exports.ZERO_LENGTH = {
+    type: 17 /* TokenType.NUMBER_TOKEN */,
+    number: 0,
+    flags: tokenizer_1.FLAG_INTEGER
+};
+exports.FIFTY_PERCENT = {
+    type: 16 /* TokenType.PERCENTAGE_TOKEN */,
+    number: 50,
+    flags: tokenizer_1.FLAG_INTEGER
+};
+exports.HUNDRED_PERCENT = {
+    type: 16 /* TokenType.PERCENTAGE_TOKEN */,
+    number: 100,
+    flags: tokenizer_1.FLAG_INTEGER
+};
+const getAbsoluteValueForTuple = (tuple, width, height) => {
+    const [x, y] = tuple;
+    return [(0, exports.getAbsoluteValue)(x, width), (0, exports.getAbsoluteValue)(typeof y !== 'undefined' ? y : x, height)];
+};
+exports.getAbsoluteValueForTuple = getAbsoluteValueForTuple;
+const getAbsoluteValue = (token, parent) => {
+    if ((0, exports.isCalcWithPercentage)(token)) {
+        return (token._calcPercentage / 100) * parent + token._calcPixelOffset;
+    }
+    if (token.type === 16 /* TokenType.PERCENTAGE_TOKEN */) {
+        return (token.number / 100) * parent;
+    }
+    if ((0, parser_1.isDimensionToken)(token)) {
+        switch (token.unit) {
+            case 'rem':
+            case 'em':
+                // NOTE: Assumes a 16px root font-size for rem/em units. A fully
+                // accurate implementation would require access to the element's
+                // computed font-size (em) or the root element's font-size (rem),
+                // which are not available in this pure-resolution function.
+                return 16 * token.number;
+            case 'px':
+            default:
+                return token.number;
+        }
+    }
+    return token.number;
+};
+exports.getAbsoluteValue = getAbsoluteValue;

package/dist/lib/css/types/length.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLength = void 0;
+const isLength = (token) => token.type === 17 /* TokenType.NUMBER_TOKEN */ || token.type === 15 /* TokenType.DIMENSION_TOKEN */;
+exports.isLength = isLength;

package/dist/lib/css/types/safe-eval.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * Safe arithmetic expression evaluator — replaces `new Function()`.
+ *
+ * Supports only: numbers, +, -, *, /, parentheses.
+ * Does NOT execute arbitrary code. Returns NaN on any illegal token.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+// Regex that matches a token: number (int or float) | operator | parentheses
+const ARITH_TOKEN_RE = /(\d+(?:\.\d+)?|[+\-*/()])/g;
+const safeEvalArithmetic = (expr) => {
+    const tokens = expr.match(ARITH_TOKEN_RE);
+    if (!tokens) {
+        return NaN;
+    }
+    // Shunting-yard algorithm: infix → postfix (RPN), then evaluate.
+    const output = [];
+    const ops = [];
+    const precedence = { '+': 1, '-': 1, '*': 2, '/': 2 };
+    for (const tok of tokens) {
+        if (/^\d+(?:\.\d+)?$/.test(tok)) {
+            output.push(parseFloat(tok));
+        }
+        else if (tok === '(') {
+            ops.push(tok);
+        }
+        else if (tok === ')') {
+            while (ops.length && ops[ops.length - 1] !== '(') {
+                output.push(ops.pop());
+            }
+            if (!ops.length)
+                return NaN; // mismatched parens
+            ops.pop(); // discard '('
+        }
+        else {
+            // operator: + - * /
+            while (ops.length && precedence[ops[ops.length - 1]] >= precedence[tok]) {
+                output.push(ops.pop());
+            }
+            ops.push(tok);
+        }
+    }
+    while (ops.length) {
+        const op = ops.pop();
+        if (op === '(')
+            return NaN; // mismatched parens
+        output.push(op);
+    }
+    // Evaluate RPN
+    const stack = [];
+    for (const item of output) {
+        if (typeof item === 'number') {
+            stack.push(item);
+        }
+        else {
+            const b = stack.pop();
+            const a = stack.pop();
+            if (a === undefined || b === undefined)
+                return NaN;
+            switch (item) {
+                case '+':
+                    stack.push(a + b);
+                    break;
+                case '-':
+                    stack.push(a - b);
+                    break;
+                case '*':
+                    stack.push(a * b);
+                    break;
+                case '/':
+                    stack.push(b === 0 ? NaN : a / b);
+                    break;
+                default:
+                    return NaN;
+            }
+        }
+    }
+    return stack.length === 1 ? stack[0] : NaN;
+};
+exports.default = safeEvalArithmetic;

package/dist/lib/css/types/time.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.time = void 0;
+exports.time = {
+    name: 'time',
+    parse: (_context, value) => {
+        if (value.type === 15 /* TokenType.DIMENSION_TOKEN */) {
+            switch (value.unit.toLowerCase()) {
+                case 's':
+                    return 1000 * value.number;
+                case 'ms':
+                    return value.number;
+            }
+        }
+        throw new Error(`Unsupported time type`);
+    }
+};