iobroker.javascript 8.9.2 → 9.0.0

package/lib/adapter-config.d.ts

@@ -1,16 +0,0 @@
-// This file extends the AdapterConfig type from "@types/iobroker"
-// using the actual properties present in io-package.json
-// in order to provide typings for adapter.config properties
-
-import { native } from '../io-package.json';
-
-type _AdapterConfig = typeof native;
-
-// Augment the globally declared type ioBroker.AdapterConfig
-declare global {
-    namespace ioBroker {
-        interface AdapterConfig extends _AdapterConfig {
-            // Do not enter anything here!
-        }
-    }
-}

package/lib/consts.js

@@ -1,83 +0,0 @@
-'use strict';
-
-const dayOfWeeksFull = {
-    en: ['Sunday',        'Monday',        'Tuesday',     'Wednesday',    'Thursday',     'Friday',      'Saturday'],
-    de: ['Sonntag',       'Montag',        'Dienstag',    'Mittwoch',     'Donnerstag',   'Freitag',     'Samstag'],
-    ru: ['Воскресенье',   'Понедельник',   'Вторник',     'Среда',        'Четверг',      'Пятница',     'Суббота'],
-    pt: ['Domingo',       'Segunda-feira', 'Terça-feira', 'Quarta-feira', 'Quinta-feira', 'Sexta-feira', 'Sábado'],
-    nl: ['Zondag',        'Maandag',       'Dinsdag',     'Woensdag',     'Donderdag',    'Vrijdag',     'Zaterdag'],
-    fr: ['Dimanche',      'Lundi',         'Mardi',       'Mercredi',     'Jeudi',        'Vendredi',    'Samedi'],
-    it: ['Domenica',      'Lunedì',        'Martedì',     'Mercoledì',    'Giovedì',      'Venerdì',     'Sabato'],
-    es: ['Domingo',       'Lunes',         'Martes',      'Miércoles',    'Jueves',       'Viernes',     'Sábado'],
-    pl: ['Niedziela',     'Poniedziałek',  'Wtorek',      'Środa',        'Czwartek',     'Piątek',      'Sobota'],
-    uk: ['неділя',        'понеділок',     'вівторок',    'Середа',       'четвер',       'П\'ятниця',   'Субота'],
-    'zh-cn': ['星期日',    '星期一',         '星期二',       '星期三',        '星期四',        '星期五',       '星期六'],
-};
-const dayOfWeeksShort = {
-    en: ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'],
-    de: ['So', 'Mo', 'Di', 'Mi', 'Do', 'Fr', 'Sa'],
-    ru: ['Вс', 'Пн', 'Вт', 'Ср', 'Чт', 'Пт', 'Сб'],
-    pt: ['Do', 'Se', 'Te', 'Qu', 'Qu', 'Se', 'Sá'],
-    nl: ['Zo', 'Ma', 'Di', 'Wo', 'Do', 'Vr', 'Za'],
-    fr: ['Di', 'Lu', 'Ma', 'Me', 'Je', 'Ve', 'Sa'],
-    it: ['Do', 'Lu', 'Ma', 'Me', 'Gi', 'Ve', 'Sa'],
-    es: ['Do', 'Lu', 'Ma', 'Mi', 'Ju', 'Vi', 'Sá'],
-    pl: ['Ni', 'Po', 'Wt', 'Śr', 'Cz', 'Pi', 'So'],
-    uk: ['Нд', 'Пн', 'Вт', 'Ср', 'Чт', 'Пт', 'Сб'],
-    'zh-cn': ['星期日',  '星期一',      '星期二',         '星期三',       '星期四',         '星期五',    '星期六'],
-};
-
-const monthFull = {
-    en: ['January', 'February',  'March',    'April',    'May',     'June',     'July',    'August',   'September',  'October',     'November',  'December'],
-    de: ['Januar',  'Februar',   'März',     'April',    'Mai',     'Juni',     'Juli',    'August',   'September',  'Oktober',     'November',  'Dezember'],
-    ru: ['Январь',  'Февраль',   'Март',     'Апрель',   'Май',     'Июнь',     'Июль',    'Август',   'Сентябрь',   'Октябрь',     'Ноябрь',    'Декабрь'],
-    pt: ['Janeiro', 'Fevereiro', 'Março',    'Abril',    'Maio',    'Junho',    'Julho',   'Agosto',   'Setembro',   'Outubro',     'Novembro',  'Dezembro'],
-    nl: ['Januari', 'Februari',  'Maart',    'April',    'Mei',     'Juni',     'Juli',    'Augustus', 'September',  'Oktober',     'November',  'December'],
-    fr: ['Janvier', 'Février',   'Mars',     'Avril',    'Mai',     'Juin',     'Juillet', 'Août',     'Septembre',  'Octobre',     'Novembre',  'Décembre'],
-    it: ['Gennaio', 'Febbraio',  'Marzo',    'Aprile',   'Maggio',  'Giugno',   'Luglio',  'Agosto',   'Settembre',  'Ottobre',     'Novembre',  'Dicembre'],
-    es: ['Enero',   'Febrero',   'Marzo',    'Abril',    'Mayo',    'Junio',    'Julio',   'Agosto',   'Septiembre', 'Octubre',     'Noviembre', 'Diciembre'],
-    pl: ['Styczeń', 'Luty',      'Marzec',   'Kwiecień', 'Maj',     'Czerwiec', 'Lipiec',  'Sierpień', 'Wrzesień',   'Październik', 'Listopad',  'Grudzień'],
-    uk: ['Січень',  'Лютий',     'Березень', 'Квітень',  'Травень', 'Червень',  'Липень',  'Серпень',  'Вересень',   'Жовтень',     'Листопад',  'Грудень'],
-    'zh-cn': ['1月', '2月',       '3月',      '4月',      '5月',      '6月',      '7月',     '8月',       '9月',        '10月',        '11月',       '12月'],
-};
-
-const monthFullGen = {
-    en: ['January', 'February',  'March',    'April',    'May',     'June',     'July',    'August',   'September',  'October',     'November',  'December'],
-    de: ['Januar',  'Februar',   'März',     'April',    'Mai',     'Juni',     'Juli',    'August',   'September',  'Oktober',     'November',  'Dezember'],
-    ru: ['Января',  'Февраля',   'Марта',    'Апреля',   'Мая',     'Июня',     'Июля',    'Августа',  'Сентября',   'Октября',     'Ноября',    'Декабря'],
-    pt: ['Janeiro', 'Fevereiro', 'Março',    'Abril',    'Maio',    'Junho',    'Julho',   'Agosto',   'Setembro',   'Outubro',     'Novembro',  'Dezembro'],
-    nl: ['Januari', 'Februari',  'Maart',    'April',    'Mei',     'Juni',     'Juli',    'Augustus', 'September',  'Oktober',     'November',  'December'],
-    fr: ['Janvier', 'Février',   'Mars',     'Avril',    'Mai',     'Juin',     'Juillet', 'Août',     'Septembre',  'Octobre',     'Novembre',  'Décembre'],
-    it: ['Gennaio', 'Febbraio',  'Marzo',    'Aprile',   'Maggio',  'Giugno',   'Luglio',  'Agosto',   'Settembre',  'Ottobre',     'Novembre',  'Dicembre'],
-    es: ['Enero',   'Febrero',   'Marzo',    'Abril',    'Mayo',    'Junio',    'Julio',   'Agosto',   'Septiembre', 'Octubre',     'Noviembre', 'Diciembre'],
-    pl: ['Styczeń', 'Luty',      'Marzec',   'Kwiecień', 'Maj',     'Czerwiec', 'Lipiec',  'Sierpień', 'Wrzesień',   'Październik', 'Listopad',  'Grudzień'],
-    uk: ['Січень',  'Лютий',     'Березень', 'Квітень',  'Травень', 'Червень',  'Липень',  'Серпень',  'Вересень',   'Жовтень',     'Листопад',  'Грудень'],
-    'zh-cn': ['1月', '2月',       '3月',      '4月',      '5月',      '6月',      '7月',     '8月',       '9月',        '10月',        '11月',       '12月'],
-};
-
-const monthShort = {
-    en: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'June', 'July', 'Aug', 'Sept', 'Oct', 'Nov', 'Dec'],
-    de: ['Jan', 'Feb', 'Mär', 'Apr', 'Mai', 'Jun',  'Jul',  'Aug', 'Sep',  'Okt', 'Nov', 'Dez'],
-    ru: ['Янв', 'Фев', 'Мар', 'Апр', 'Май', 'Июнь', 'Июль', 'Авг', 'Сен',  'Окт', 'Ноя', 'Дек'],
-    pt: ['Jan', 'Fev', 'Mar', 'Abr', 'Mai', 'Jun',  'Jul',  'Ago', 'Set',  'Out', 'Nov', 'Dez'],
-    nl: ['Jan', 'Feb', 'Maa', 'Apr', 'Mei', 'Jun',  'Jul',  'Aug', 'Sep',  'Okt', 'Nov', 'Dec'],
-    fr: ['Jan', 'Fév', 'Mar', 'Avr', 'Mai', 'Jui',  'Jui',  'Aoû', 'Sep',  'Oct', 'Nov', 'Déc'],
-    it: ['Gen', 'Feb', 'Mar', 'Apr', 'Mag', 'Giu',  'Lug',  'Ago', 'Set',  'Ott', 'Nov', 'Dic'],
-    es: ['Ene', 'Feb', 'Mar', 'Abr', 'May', 'Jun',  'Jul',  'Ago', 'Sep',  'Oct', 'Nov', 'Dic'],
-    pl: ['Sty', 'Lut', 'Mar', 'Kwi', 'Maj', 'Cze',  'Lip',  'Sie', 'Wrz',  'Paź', 'Lis', 'Gru'],
-    uk: ['Січ', 'Лют', 'Бер', 'Кві', 'Тра', 'Чер',  'Лип',  'Сер', 'Вер',  'Жов', 'Лис', 'Гру'],
-    'zh-cn': ['1月', '2月', '3月', '4月', '5月', '6月', '7月', '8月', '9月',  '10月', '11月', '12月'],
-};
-
-const astroList = ['sunrise', 'sunset', 'sunriseEnd', 'sunsetStart', 'dawn', 'dusk', 'nauticalDawn', 'nauticalDusk', 'nadir', 'nightEnd', 'night', 'goldenHourEnd', 'goldenHour', 'solarNoon'];
-const astroListLow = astroList.map(str => str.toLowerCase());
-
-module.exports = {
-    dayOfWeeksFull,
-    dayOfWeeksShort,
-    monthFull,
-    monthFullGen,
-    monthShort,
-    astroList,
-    astroListLow
-};

package/lib/convert.js

@@ -1,106 +0,0 @@
-'use strict';
-
-// controller uses this file when build uploads
-function stringify(data) {
-    let obj = data.data;
-    let id =  data.id;
-    if (data.data.type === 'channel') {
-        id = `${id.replace(/\./g, '/').substring('script.js.'.length)}/_dir.json`;
-        obj = JSON.stringify(obj, null, 2);
-    } else if (data.data.type === 'script') {
-        id = `${id.replace(/\./g, '/').substring('script.js.'.length)}.json`;
-        if (obj.common && obj.common.source) {
-            const source = obj.common.source;
-            if (obj.common.enabled) delete obj.common.enabled;
-            if (obj.common.engine === 'system.adapter.javascript.0') delete obj.common.engine;
-            if (obj.common.engineType === 'Javascript/js') delete obj.common.engineType;
-            delete obj.common.name;
-            delete obj.common.source;
-            if (JSON.stringify(obj.common) !== '{}') {
-                obj = `/* -- do not edit following lines - START --\n${JSON.stringify(obj.common, null, 2)}\n-- do not edit previous lines - END --*/\n${source}`;
-            } else {
-                obj = source;
-            }
-        } else {
-            obj = JSON.stringify(obj, null, 2);
-        }
-    }
-
-    return {id: id, data: obj};
-}
-
-function parse(data) {
-    let obj = data.data;
-    let id  = data.id;
-    let error;
-    let name;
-    if (id[id.length - 1] === '/') {
-        id = id.substring(0, id.length - 1);
-    }
-
-    if (!id.match(/\.json$/)) {
-        return null;
-    }
-
-    if (id.match(/_dir\.json$/)) {
-        name = id.substring(0, id.length - '/_dir.json'.length).replace(/\//g, '.');
-
-        try {
-            obj = JSON.parse(obj);
-        } catch (e) {
-            error = `Cannot parse object "${name}": ${e}`;
-            obj = {
-                common: {
-                    name: name.split('.').pop(),
-                },
-                type: 'channel',
-                _id: `script.js.${name}`,
-            };
-        }
-        id = `script.js.${name}`;
-    } else {
-        //script
-        name = id.substring(0, id.length - '.json'.length).replace(/\//g, '.');
-        let source;
-        if (obj.match(/^\/\*\s--\sdo\snot/)) {
-            obj = obj.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
-            const lines = obj.split('\n');
-            let stringObj = '';
-            let line = 1;
-            while (line < lines.length) {
-                if (lines[line].match(/^--\sdo\snot/)) {
-                    break;
-                }
-                stringObj += lines[line];
-                line++;
-            }
-            lines.splice(0, line + 1);
-            source = lines.join('\n');
-            try {
-                obj = {};
-                obj.common = JSON.parse(stringObj);
-                obj.common.source = source;
-            } catch (e) {
-                error = `Cannot parse object "${id}": ${e}`;
-            }
-        } else {
-            source = obj;
-            obj = null;
-        }
-
-        obj                     = obj || {};
-        obj.common              = obj.common || {};
-        obj._id                 = `script.js.${name}`;
-        obj.type                = 'script';
-        obj.common.name         = name.split('.').pop();
-        obj.common.enabled      = (obj.common.enabled === undefined) ? true : obj.common.enabled;
-        obj.common.engine       = obj.common.engine || 'system.adapter.javascript.0';
-        obj.common.engineType   = obj.common.engineType || 'Javascript/js';
-        obj.common.source       = obj.common.source || source;
-        id = `script.js.${name}`;
-    }
-
-    return { id: id, data: obj, error: error };
-}
-module.exports.stringify = stringify;
-module.exports.parse     = parse;

package/lib/debug.js

@@ -1,154 +0,0 @@
-const fork           = require('node:child_process').fork;
-
-const adapter = {
-    log: {
-        error: text => console.error(text),
-        info: text => console.log(text),
-        warn: text => console.warn(text),
-        debug: text => console.log(text),
-    },
-    setState: (id, val) => {
-        try {
-            val = JSON.parse(val);
-        } catch (e) {
-            console.error(e);
-        }
-        console.log(`FROM: ${JSON.stringify(val)}`);
-    }
-};
-const context = {
-    objects: {}
-};
-
-const debugState = {
-    scriptName: '',
-    child: null,
-    promiseOnEnd: null,
-    paused: false,
-};
-
-function stopDebug() {
-    if (debugState.child) {
-        sendToInspector({ cmd: 'end' });
-        debugState.endTimeout = setTimeout(() => {
-            debugState.endTimeout = null;
-            debugState.child.kill('SIGTERM');
-        });
-    } else {
-        debugState.promiseOnEnd = Promise.resolve();
-    }
-
-    return debugState.promiseOnEnd
-        .then(() => {
-            debugState.child = null;
-            debugState.running = false;
-            debugState.scriptName = '';
-            debugState.endTimeout && clearTimeout(debugState.endTimeout);
-            debugState.endTimeout = null;
-        });
-}
-
-function disableScript(id) {
-    const obj = context.objects[id];
-    if (obj && obj.common && obj.common.enabled) {
-        return adapter.extendForeignObjectAsync(obj._id, {common: {enabled: false}});
-    } else {
-        return Promise.resolve();
-    }
-}
-
-function sendToInspector(message) {
-    if (typeof message === 'string') {
-        try {
-            message = JSON.parse(message);
-        } catch (e) {
-            adapter.log.error(`Cannot parse message to inspector: ${message}`);
-            return adapter.setState('debug.from', JSON.stringify({ error: 'Cannot parse message to inspector' }));
-        }
-    }
-
-    if (debugState.child) {
-        debugState.child.send(JSON.stringify(message));
-    } else {
-        adapter.log.error(`Cannot send command to terminated inspector`);
-        return adapter.setState('debug.from', JSON.stringify({ error: `Cannot send command to terminated inspector` }));
-    }
-}
-
-function childPrint(text) {
-    console.log(
-        text.toString()
-            .split(/\r\n|\r|\n/g)
-            .filter((chunk) => !!chunk)
-            .map((chunk) => `< ${chunk}`)
-            .join('\n')
-    );
-}
-
-function debugScript(data) {
-    // stop a script if it is running
-
-    return disableScript(data.scriptName)
-        .then(() => stopDebug())
-        .then(() => {
-            debugState.scriptName   = data.scriptName;
-            debugState.breakOnStart = data.breakOnStart;
-
-            const options = {
-                stdio: ['ignore', 'inherit', 'inherit', 'ipc']
-            };
-
-            debugState.child = fork(`${__dirname}/../inspect.js`, [], options);
-
-            /*debugState.child.stdout.setEncoding('utf8');
-            debugState.child.stderr.setEncoding('utf8');
-            debugState.child.stdout.on('data', childPrint);
-            debugState.child.stderr.on('data', childPrint);*/
-
-            debugState.child.on('message', message => {
-                try {
-                    message = JSON.parse(message);
-                } catch (e) {
-                    return adapter.log.error(`Cannot parse message from inspector: ${message}`);
-                }
-
-                adapter.setState('debug.from', JSON.stringify(message));
-
-                switch (message.cmd) {
-                    case 'ready': {
-                        debugState.child.send(JSON.stringify({ cmd: 'start', scriptName: debugState.scriptName }));
-                        break;
-                    }
-
-                    case 'watched': {
-                        console.log(`WATCHED: ${JSON.stringify(message)}`);
-                        break;
-                    }
-
-                    case 'paused': {
-                        debugState.paused = true;
-                        console.log(`PAUSED`);
-                        break;
-                    }
-
-                    case 'resumed' : {
-                        debugState.paused = false;
-                        console.log(`STARTED`);
-                        break;
-                    }
-
-                    case 'log' : {
-                        console.log(`[${message.severity}] ${message.text}`);
-                        break;
-                    }
-
-                    case 'readyToDebug': {
-                        console.log(`readyToDebug (set breakpoints): [${message.scriptId}] ${message.script}`);
-                        break;
-                    }
-                }
-            });
-        });
-}
-
-debugScript({ scriptName: 'script.js.Skript_1' });

package/lib/eventObj.js

@@ -1,201 +0,0 @@
-'use strict';
-let inited = false;
-
-function getObjectEnumsSync(context, idObj, enumIds, enumNames) {
-    if (!enumIds)   enumIds   = [];
-    if (!enumNames) enumNames = [];
-
-    if (context.cacheObjectEnums[idObj]) {
-        for (const enumId of context.cacheObjectEnums[idObj].enumIds) {
-            if (!enumIds.includes(enumId)) {
-                enumIds.push(enumId);
-            }
-        }
-        for (const enumName of context.cacheObjectEnums[idObj].enumNames) {
-            if (!enumNames.includes(enumName)) {
-                enumNames.push(enumName);
-            }
-        }
-        return {enumIds: enumIds, enumNames: enumNames};
-    }
-
-
-    for (let i = 0, l = context.enums.length; i < l; i++) {
-        if (context.objects[context.enums[i]] &&
-            context.objects[context.enums[i]].common &&
-            context.objects[context.enums[i]].common.members &&
-            context.objects[context.enums[i]].common.members.indexOf(idObj) !== -1) {
-            if (enumIds.indexOf(context.enums[i]) === -1) enumIds.push(context.enums[i]);
-            if (enumNames.indexOf(context.objects[context.enums[i]].common.name) === -1) enumNames.push(context.objects[context.enums[i]].common.name);
-        }
-    }
-
-    if (context.objects[idObj]) {
-        const pos = idObj.lastIndexOf('.');
-        if (pos !== -1) {
-            const parent = idObj.substring(0, pos);
-            if (parent && context.objects[parent]) {
-                const parentEnumIds = [];
-                const parentEnumNames = [];
-                //get parent enums but do not propagate our enums to parent.
-                getObjectEnumsSync(context, parent, parentEnumIds, parentEnumNames);
-                for (const enumId of parentEnumIds) {
-                    if (!enumIds.includes(enumId)) {
-                        enumIds.push(enumId);
-                    }
-                }
-                for (const enumName of parentEnumNames) {
-                    if (!enumNames.includes(enumName)) {
-                        enumNames.push(enumName);
-                    }
-                }
-            }
-        }
-    }
-
-    context.cacheObjectEnums[idObj] = {enumIds: enumIds, enumNames: enumNames};
-    return context.cacheObjectEnums[idObj];
-}
-
-function doGetter(obj, name, ret) {
-    //adapter.log.debug('getter: ' + name + ' returns ' + ret);
-    Object.defineProperty(obj, name, {value: ret});
-    return ret;
-}
-
-function EventObj(id, state, oldState) {
-    if (!(this instanceof EventObj)) {
-        return new EventObj(id, state, oldState);
-    }
-    this.id = id;
-    this.newState = {
-        val:  state.val,
-        ts:   state.ts,
-        ack:  state.ack,
-        lc:   state.lc,
-        from: state.from,
-        q:    state.q,
-        c:    state.c,
-        user: state.user,
-    };
-    //if (oldState === undefined) oldState = {};
-    if (!oldState) {
-        this.oldState = {
-            val:  undefined,
-            ts:   undefined,
-            ack:  undefined,
-            lc:   undefined,
-            from: undefined,
-            q:    undefined,
-            c:    undefined,
-            user: undefined,
-        };
-    } else {
-        this.oldState = {
-            val:  oldState.val,
-            ts:   oldState.ts,
-            ack:  oldState.ack,
-            lc:   oldState.lc,
-            from: oldState.from,
-            q:    oldState.q,
-            c:    oldState.c,
-            user: oldState.user,
-        };
-    }
-    this.state = this.newState;
-}
-
-function createEventObject(context, id, state, oldState) {
-    if (!inited) {
-        inited = true;
-        const eventObjectProperties = {
-            common: {
-                get: function () {
-                    const ret = context.objects[this.id] ? context.objects[this.id].common : {};
-                    return doGetter(this, 'common', ret);
-                },
-                configurable: true,
-            },
-            native: {
-                get: function () {
-                    const ret = context.objects[this.id] ? context.objects[this.id].native : {};
-                    return doGetter(this, 'native', ret);
-                },
-                configurable: true,
-            },
-            name: {
-                get: function () {
-                    const ret = this.common ? this.common.name : null;
-                    return doGetter(this, 'name', ret);
-                },
-                configurable: true,
-            },
-            channelId: {
-                get: function () {
-                    const ret = this.id.replace (/\.*[^.]+$/, '');
-                    return doGetter(this, 'channelId', context.objects[ret] ? ret : null);
-                },
-                configurable: true,
-            },
-            channelName: {
-                get: function () {
-                    const channelId = this.channelId;
-                    const ret = channelId && context.objects[channelId].common ? context.objects[channelId].common.name : null;
-                    return doGetter(this, 'channelName', ret);
-                },
-                configurable: true,
-            },
-            deviceId: {
-                get: function () {
-                    let deviceId;
-                    const channelId = this.channelId;
-                    if (!channelId || !(deviceId = channelId.replace (/\.*[^.]+$/, '')) || !context.objects[deviceId]) {
-                        Object.defineProperty(this, 'deviceName', { value: null });
-                        return doGetter(this, 'deviceId', null);
-                    }
-                    return doGetter(this, 'deviceId', deviceId);
-                },
-                configurable: true,
-            },
-            deviceName: {
-                get: function () {
-                    const deviceId = this.deviceId;
-                    const ret = deviceId && context.objects[deviceId].common ? context.objects[deviceId].common.name : null;
-                    return doGetter(this, 'deviceName', ret);
-                },
-                configurable: true,
-            },
-            enumIds: {
-                get: function () {
-                    if (!context.isEnums) return undefined;
-                    const enumIds = [];
-                    const enumNames = [];
-                    getObjectEnumsSync(context, this.id, enumIds, enumNames);
-                    Object.defineProperty(this, 'enumNames', { value: enumNames });
-                    return doGetter(this, 'enumIds', enumIds);
-                },
-                configurable: true,
-            },
-            enumNames: {
-                get: function () {
-                    if (!context.isEnums) return undefined;
-                    const enumIds = [];
-                    const enumNames = [];
-                    getObjectEnumsSync(context, this.id, enumIds, enumNames);
-                    Object.defineProperty(this, 'enumIds', { value: enumIds });
-                    return doGetter(this, 'enumNames', enumNames);
-                },
-                configurable: true,
-            }
-        };
-        Object.defineProperties(EventObj.prototype, eventObjectProperties);
-        inited = true;
-    }
-
-    return new EventObj(id, state, oldState);
-}
-
-module.exports = {
-    createEventObject,
-    getObjectEnumsSync
-};