Migrate Core modules to TS

packages/devextreme/js/__internal/.eslintrc.js

@@ -199,6 +199,28 @@ module.exports = {
                 '@typescript-eslint/explicit-function-return-type': 'warn'
             }
         },
+        // Rules for migrated core files.
+        {
+            files: [
+                '**/core/**/m_*.ts',
+            ],
+            parser: '@typescript-eslint/parser',
+            parserOptions: {
+                createDefaultProgram: true,
+                project: './tsconfig.json',
+                tsconfigRootDir: __dirname,
+            },
+            rules: {
+                'guard-for-in': 'off',
+                'no-restricted-syntax': 'off',
+                'func-style': 'off',
+                'wrap-iife': 'off',
+                'prefer-arrow-callback': 'off',
+                '@typescript-eslint/prefer-optional-chain': 'off',
+                'radix': 'off',
+                'object-shorthand': 'off'
+            },
+        },
     ],
     settings: {
         'import/resolver': {

packages/devextreme/js/__internal/core/m_action.ts

@@ -0,0 +1,174 @@
+/* eslint-disable guard-for-in */
+/* eslint-disable @typescript-eslint/prefer-for-of */
+/* eslint-disable no-restricted-syntax */
+import $ from '@js/core/renderer';
+import { each } from '@js/core/utils/iterator';
+import { isFunction, isPlainObject } from '@js/core/utils/type';
+import { getWindow } from '@js/core/utils/window';
+
+class Action {
+  _action: any;
+
+  _context: any;
+
+  _beforeExecute: any;
+
+  _afterExecute: any;
+
+  _component: any;
+
+  _validatingTargetName: any;
+
+  _excludeValidators: any;
+
+  static executors: any;
+
+  constructor(action, config?) {
+    config = config || {};
+    this._action = action;
+    this._context = config.context || getWindow();
+    this._beforeExecute = config.beforeExecute;
+    this._afterExecute = config.afterExecute;
+    this._component = config.component;
+    this._validatingTargetName = config.validatingTargetName;
+    const excludeValidators = this._excludeValidators = {};
+
+    if (config.excludeValidators) {
+      for (let i = 0; i < config.excludeValidators.length; i++) {
+        excludeValidators[config.excludeValidators[i]] = true;
+      }
+    }
+  }
+
+  execute(...args) {
+    const e = {
+      action: this._action,
+      args: Array.prototype.slice.call(args),
+      context: this._context,
+      component: this._component,
+      validatingTargetName: this._validatingTargetName,
+      cancel: false,
+      handled: false,
+    };
+
+    const beforeExecute = this._beforeExecute;
+    const afterExecute = this._afterExecute;
+
+    const argsBag = e.args[0] || {};
+
+    if (!this._validateAction(e)) {
+      return;
+    }
+
+    beforeExecute?.call(this._context, e);
+
+    if (e.cancel) {
+      return;
+    }
+
+    const result = this._executeAction(e);
+
+    if (argsBag.cancel) {
+      return;
+    }
+
+    afterExecute?.call(this._context, e);
+
+    return result;
+  }
+
+  _validateAction(e) {
+    const excludeValidators = this._excludeValidators;
+    const { executors } = Action;
+
+    // eslint-disable-next-line no-restricted-syntax
+    for (const name in executors) {
+      if (!excludeValidators[name]) {
+        const executor = executors[name];
+        executor.validate?.(e);
+
+        if (e.cancel) {
+          return false;
+        }
+      }
+    }
+
+    return true;
+  }
+
+  _executeAction(e) {
+    let result;
+    const { executors } = Action;
+
+    for (const name in executors) {
+      const executor = executors[name];
+      executor.execute?.(e);
+
+      if (e.handled) {
+        result = e.result;
+        break;
+      }
+    }
+
+    return result;
+  }
+
+  static registerExecutor(name, executor) {
+    if (isPlainObject(name)) {
+      each(name, Action.registerExecutor);
+      return;
+    }
+    Action.executors[name] = executor;
+  }
+
+  static unregisterExecutor(...args) {
+    each(args, function () {
+      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+      delete Action.executors[this];
+    });
+  }
+}
+
+Action.executors = {};
+
+const createValidatorByTargetElement = (condition) => (e) => {
+  if (!e.args.length) {
+    return;
+  }
+
+  const args = e.args[0];
+  const element = args[e.validatingTargetName] || args.element;
+
+  if (element && condition($(element))) {
+    e.cancel = true;
+  }
+};
+// @ts-expect-error expect name and executor
+Action.registerExecutor({
+  disabled: {
+    validate: createValidatorByTargetElement(($target) => $target.is('.dx-state-disabled, .dx-state-disabled *')),
+  },
+
+  readOnly: {
+    validate: createValidatorByTargetElement(($target) => $target.is('.dx-state-readonly, .dx-state-readonly *:not(.dx-state-independent)')),
+  },
+  undefined: {
+    execute: (e) => {
+      if (!e.action) {
+        e.result = undefined;
+        e.handled = true;
+      }
+    },
+  },
+  func: {
+    execute: (e) => {
+      if (isFunction(e.action)) {
+        e.result = e.action.call(e.context, e.args[0]);
+        e.handled = true;
+      }
+    },
+  },
+});
+
+export { Action };
+export default Action;

packages/devextreme/js/__internal/core/m_class.ts

@@ -0,0 +1,157 @@
+import errors from '@js/core/errors';
+import { isWindow } from '@js/core/utils/type';
+
+const wrapOverridden = function (baseProto, methodName, method) {
+  return function () {
+    const prevCallBase = this.callBase;
+    this.callBase = baseProto[methodName];
+    try {
+      return method.apply(this, arguments);
+    } finally {
+      this.callBase = prevCallBase;
+    }
+  };
+};
+
+const clonePrototype = function (obj) {
+  const func = function () { };
+  func.prototype = obj.prototype;
+  // eslint-disable-next-line new-cap
+  return new func();
+};
+
+const redefine = function (members) {
+  const that = this;
+  let overridden;
+  let memberName;
+  let member;
+
+  if (!members) {
+    return that;
+  }
+
+  for (memberName in members) {
+    member = members[memberName];
+    overridden = typeof that.prototype[memberName] === 'function' && typeof member === 'function';
+    that.prototype[memberName] = overridden ? wrapOverridden(that.parent.prototype, memberName, member) : member;
+  }
+
+  return that;
+};
+
+const include = function (...args) {
+  const classObj = this;
+  let argument;
+  let name;
+  let i;
+
+  // NOTE: For ES6 classes. They don't have _includedCtors/_includedPostCtors
+  // properties and get them from the ancestor class.
+  const hasClassObjOwnProperty = Object.prototype.hasOwnProperty.bind(classObj);
+  const isES6Class = !hasClassObjOwnProperty('_includedCtors') && !hasClassObjOwnProperty('_includedPostCtors');
+
+  if (isES6Class) {
+    classObj._includedCtors = classObj._includedCtors.slice(0);
+    classObj._includedPostCtors = classObj._includedPostCtors.slice(0);
+  }
+
+  for (i = 0; i < args.length; i++) {
+    argument = args[i];
+    if (argument.ctor) {
+      classObj._includedCtors.push(argument.ctor);
+    }
+    if (argument.postCtor) {
+      classObj._includedPostCtors.push(argument.postCtor);
+    }
+
+    // eslint-disable-next-line no-restricted-syntax
+    for (name in argument) {
+      if (name === 'ctor' || name === 'postCtor' || name === 'default') {
+        continue;
+      }
+      /// #DEBUG
+      if (name in classObj.prototype) {
+        throw errors.Error('E0002', name);
+      }
+      /// #ENDDEBUG
+      classObj.prototype[name] = argument[name];
+    }
+  }
+
+  return classObj;
+};
+
+const subclassOf = function (parentClass) {
+  const hasParentProperty = Object.prototype.hasOwnProperty.bind(this)('parent');
+  const isES6Class = !hasParentProperty && this.parent;
+
+  if (isES6Class) {
+    const baseClass = Object.getPrototypeOf(this);
+
+    return baseClass === parentClass || baseClass.subclassOf(parentClass);
+  }
+  if (this.parent === parentClass) {
+    return true;
+  }
+
+  if (!this.parent || !this.parent.subclassOf) {
+    return false;
+  }
+
+  return this.parent.subclassOf(parentClass);
+};
+
+const abstract = function () {
+  throw errors.Error('E0001');
+};
+
+const classImpl = function () { };
+
+classImpl.inherit = function (members) {
+  const inheritor = function (...args) {
+    if (!this || isWindow(this) || typeof this.constructor !== 'function') {
+      throw errors.Error('E0003');
+    }
+
+    const instance = this;
+    const { ctor } = instance;
+    const includedCtors = instance.constructor._includedCtors;
+    const includedPostCtors = instance.constructor._includedPostCtors;
+    let i;
+
+    for (i = 0; i < includedCtors.length; i++) {
+      includedCtors[i].call(instance);
+    }
+
+    if (ctor) {
+      ctor.apply(instance, args);
+    }
+
+    for (i = 0; i < includedPostCtors.length; i++) {
+      includedPostCtors[i].call(instance);
+    }
+  };
+
+  inheritor.prototype = clonePrototype(this);
+
+  Object.setPrototypeOf(inheritor, this);
+
+  inheritor.inherit = this.inherit;
+  inheritor.abstract = abstract;
+  inheritor.redefine = redefine;
+  inheritor.include = include;
+  inheritor.subclassOf = subclassOf;
+
+  inheritor.parent = this;
+  inheritor._includedCtors = this._includedCtors ? this._includedCtors.slice(0) : [];
+  inheritor._includedPostCtors = this._includedPostCtors ? this._includedPostCtors.slice(0) : [];
+  inheritor.prototype.constructor = inheritor;
+
+  inheritor.redefine(members);
+
+  return inheritor;
+};
+
+classImpl.abstract = abstract;
+
+export default classImpl;