rhine-var/dist/core/var/support/class/support-text.class.js

Variables that support multi-user collaboration and persistence, making collaboration and variable operations as simple as possible, with strict and well-defined type hints.

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const rhine_var_text_class_1 = __importDefault(require("../../items/rhine-var-text.class"));
const support_base_1 = __importDefault(require("../support-base"));
const index_1 = require("../../../../index");
class SupportText extends support_base_1.default {
    static convertProperty(key, object) {
        console.log('SupportText.convertProperty', key, object);
        if (!(object.getNative() instanceof index_1.YText) || !(object instanceof rhine_var_text_class_1.default)) {
            console.error('Unsupported convertProperty:', object, object.getNative());
            return;
        }
        const native = object.getNative();
        switch (key) {
            case 'insert':
                return (index, value) => {
                    native.insert(index, value);
                    return native.length;
                };
            case 'delete':
                return (index, length) => {
                    native.delete(index, length);
                    return native.length;
                };
            case 'clear':
                return () => {
                    native.delete(0, native.length);
                };
            case 'length':
                return native.length;
            case 'at':
                return (index) => {
                    return native.toString().charAt(index);
                };
            case 'charAt':
                return (index) => {
                    return native.toString().charAt(index);
                };
            case 'charCodeAt':
                return (index) => {
                    return native.toString().charCodeAt(index);
                };
            case 'codePointAt':
                return (index) => {
                    return native.toString().codePointAt(index);
                };
            case 'concat':
                return (...strings) => {
                    return native.toString().concat(...strings);
                };
            case 'endsWith':
                return (searchString, endPosition) => {
                    return native.toString().endsWith(searchString, endPosition);
                };
            case 'includes':
                return (searchString, position) => {
                    return native.toString().includes(searchString, position);
                };
            case 'indexOf':
                return (searchValue, fromIndex) => {
                    return native.toString().indexOf(searchValue, fromIndex);
                };
            case 'isWellFormed':
                return () => {
                    return native.toString().isWellFormed();
                };
            case 'lastIndexOf':
                return (searchValue, fromIndex) => {
                    return native.toString().lastIndexOf(searchValue, fromIndex);
                };
            case 'localeCompare':
                return (compareString, locales, options) => {
                    return native.toString().localeCompare(compareString, locales, options);
                };
            case 'match':
                return (regexp) => {
                    return native.toString().match(regexp);
                };
            case 'matchAll':
                return (regexp) => {
                    return native.toString().matchAll(regexp);
                };
            case 'normalize':
                return (form) => {
                    return native.toString().normalize(form);
                };
            case 'padEnd':
                return (targetLength, padString) => {
                    return native.toString().padEnd(targetLength, padString);
                };
            case 'padStart':
                return (targetLength, padString) => {
                    return native.toString().padStart(targetLength, padString);
                };
            case 'repeat':
                return (count) => {
                    return native.toString().repeat(count);
                };
            case 'replace':
                return (searchValue, replaceValue) => {
                    return native.toString().replace(searchValue, replaceValue);
                };
            case 'replaceAll':
                return (searchValue, replaceValue) => {
                    return native.toString().replaceAll(searchValue, replaceValue);
                };
            case 'search':
                return (regexp) => {
                    return native.toString().search(regexp);
                };
            case 'slice':
                return (start, end) => {
                    return native.toString().slice(start, end);
                };
            case 'split':
                return (separator, limit) => {
                    return native.toString().split(separator, limit);
                };
            case 'startsWith':
                return (searchString, position) => {
                    return native.toString().startsWith(searchString, position);
                };
            case 'substring':
                return (start, end) => {
                    return native.toString().substring(start, end);
                };
            case 'toLocaleLowerCase':
                return () => {
                    return native.toString().toLocaleLowerCase();
                };
            case 'toLocaleUpperCase':
                return () => {
                    return native.toString().toLocaleUpperCase();
                };
            case 'toLowerCase':
                return () => {
                    return native.toString().toLowerCase();
                };
            case 'toString':
                return () => {
                    return native.toString().toString();
                };
            case 'toUpperCase':
                return () => {
                    return native.toString().toUpperCase();
                };
            case 'toWellFormed':
                return () => {
                    return native.toString().toWellFormed();
                };
            case 'trim':
                return () => {
                    return native.toString().trim();
                };
            case 'trimEnd':
                return () => {
                    return native.toString().trimEnd();
                };
            case 'trimStart':
                return () => {
                    return native.toString().trimStart();
                };
            case 'valueOf':
                return () => {
                    return native.toString().valueOf();
                };
            case Symbol.iterator:
                return native.toString()[Symbol.iterator];
            default:
                return undefined;
        }
    }
}
SupportText.TARGET_TAG = 'RhineVarText';
SupportText.SUPPORTED_PROPERTIES = new Set([
    Symbol.iterator,
    Symbol.unscopables,
    'length',
    'insert',
    'delete',
    'clear',
    'at',
    'charAt',
    'charCodeAt',
    'codePointAt',
    'concat',
    'endsWith',
    'includes',
    'indexOf',
    'isWellFormed',
    'lastIndexOf',
    'localeCompare',
    'match',
    'matchAll',
    'normalize',
    'padEnd',
    'padStart',
    'repeat',
    'replace',
    'replaceAll',
    'search',
    'slice',
    'split',
    'startsWith',
    'substring',
    'toLocaleLowerCase',
    'toLocaleUpperCase',
    'toLowerCase',
    'toString',
    'toUpperCase',
    'toWellFormed',
    'trim',
    'trimEnd',
    'trimStart',
    'valueOf',
]);
SupportText.UNSUPPORTED_PROPERTIES = new Set([]);
exports.default = SupportText;