uicore-ts/compiledScripts/UIKeyValueSorter.js

UICore is a library to build native-like user interfaces using pure Typescript. No HTML is needed at all. Components are described as TS classes and all user interactions are handled explicitly. This library is strongly inspired by the UIKit framework tha

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var UIKeyValueSorter_exports = {};
__export(UIKeyValueSorter_exports, {
  UIKeyValueSorter: () => UIKeyValueSorter
});
module.exports = __toCommonJS(UIKeyValueSorter_exports);
var import_UIKeyValueSorterWebWorker = __toESM(require("./UIKeyValueSorterWebWorker.worker"));
var import_UIObject = require("./UIObject");
const _UIKeyValueSorter = class extends import_UIObject.UIObject {
  constructor(useSeparateWebWorkerHolder = import_UIObject.NO) {
    super();
    this._isThreadClosed = import_UIObject.NO;
    this._webWorkerHolder = _UIKeyValueSorter._sharedWebWorkerHolder;
    if (useSeparateWebWorkerHolder) {
      this._webWorkerHolder = {
        webWorker: new import_UIKeyValueSorterWebWorker.default(),
        UICore_isWorking: false,
        UICore_messagesToPost: void 0,
        UICore_completionFunctions: {}
      };
    }
    _UIKeyValueSorter._instanceNumber = _UIKeyValueSorter._instanceNumber + 1;
    this._instanceNumber = _UIKeyValueSorter._instanceNumber;
    if ((0, import_UIObject.IS_NOT)(this._webWorkerHolder.webWorker.onmessage)) {
      this._webWorkerHolder.webWorker.onmessage = (message) => {
        this.isWorkerBusy = import_UIObject.NO;
        this.postNextMessageIfNeeded();
        const key = "" + message.data.identifier + message.data.instanceIdentifier;
        const completionFunction = this.completionFunctions[key];
        if ((0, import_UIObject.IS)(completionFunction)) {
          completionFunction(message.data.sortedData, message.data.sortedIndexes, message.data.identifier);
        }
        delete this.completionFunctions[key];
        var asd = 1;
      };
    }
  }
  get instanceIdentifier() {
    return this._instanceNumber;
  }
  get completionFunctions() {
    const key = "UICore_completionFunctions";
    var result = this._webWorkerHolder[key];
    if ((0, import_UIObject.IS_NOT)(result)) {
      result = {};
      this._webWorkerHolder[key] = result;
    }
    return result;
  }
  get messagesToPost() {
    const key = "UICore_messagesToPost";
    var result = this._webWorkerHolder[key];
    if ((0, import_UIObject.IS_NOT)(result)) {
      result = [];
      this._webWorkerHolder[key] = result;
    }
    return result;
  }
  set isWorkerBusy(isWorkerBusy) {
    this._webWorkerHolder["UICore_isWorking"] = isWorkerBusy;
  }
  get isWorkerBusy() {
    return (0, import_UIObject.IS)(this._webWorkerHolder["UICore_isWorking"]);
  }
  postNextMessageIfNeeded() {
    if (this.messagesToPost.length && (0, import_UIObject.IS_NOT)(this.isWorkerBusy)) {
      this._webWorkerHolder.webWorker.postMessage(this.messagesToPost.firstElement);
      this.messagesToPost.removeElementAtIndex(0);
      this.isWorkerBusy = import_UIObject.YES;
    }
  }
  sortData(data, sortingInstructions, identifier, completion) {
    if (this._isThreadClosed) {
      return;
    }
    if (!(data == null ? void 0 : data.length)) {
      completion([], [], identifier);
      return;
    }
    const instanceIdentifier = this.instanceIdentifier;
    const key = "" + identifier + instanceIdentifier;
    this.completionFunctions[key] = completion;
    try {
      this.messagesToPost.push({
        "data": data,
        "sortingInstructions": sortingInstructions,
        "identifier": identifier,
        "instanceIdentifier": instanceIdentifier
      });
      this.postNextMessageIfNeeded();
    } catch (exception) {
      completion([], [], identifier);
    }
  }
  sortedData(data, sortingInstructions, identifier = (0, import_UIObject.MAKE_ID)()) {
    const result = new Promise((resolve, reject) => {
      this.sortData(data, sortingInstructions, identifier, (sortedData, sortedIndexes, sortedIdentifier) => {
        if (sortedIdentifier == identifier) {
          resolve({
            sortedData,
            sortedIndexes,
            identifier: sortedIdentifier
          });
        }
      });
    });
    return result;
  }
  closeThread() {
    this._isThreadClosed = import_UIObject.YES;
    if (this._webWorkerHolder != _UIKeyValueSorter._sharedWebWorkerHolder) {
      this._webWorkerHolder.webWorker.terminate();
    }
  }
};
let UIKeyValueSorter = _UIKeyValueSorter;
UIKeyValueSorter._sharedWebWorkerHolder = {
  UICore_completionFunctions: {},
  UICore_isWorking: false,
  UICore_messagesToPost: void 0,
  webWorker: new import_UIKeyValueSorterWebWorker.default()
};
UIKeyValueSorter._instanceNumber = -1;
UIKeyValueSorter.dataType = {
  "string": "string",
  "number": "number"
};
UIKeyValueSorter.direction = {
  "descending": "descending",
  "ascending": "ascending"
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  UIKeyValueSorter
});
//# sourceMappingURL=UIKeyValueSorter.js.map