wonder.js/lib/js/src/service/atom/ArrayService.js

3d webgl engine

'use strict';

var Curry = require("bs-platform/lib/js/curry.js");
var Caml_obj = require("bs-platform/lib/js/caml_obj.js");
var Caml_array = require("bs-platform/lib/js/caml_array.js");
var Caml_option = require("bs-platform/lib/js/caml_option.js");
var Log$WonderLog = require("wonder-log/lib/js/src/Log.js");
var Contract$WonderLog = require("wonder-log/lib/js/src/Contract.js");
var StateDataMain$Wonderjs = require("../state/main/data/StateDataMain.js");
var IsDebugMainService$Wonderjs = require("../state/main/state/IsDebugMainService.js");
var ArrayService$WonderCommonlib = require("wonder-commonlib/lib/js/src/ArrayService.js");
var MutableHashMapService$WonderCommonlib = require("wonder-commonlib/lib/js/src/MutableHashMapService.js");
var ImmutableHashMapService$WonderCommonlib = require("wonder-commonlib/lib/js/src/ImmutableHashMapService.js");

function deleteBySwap(index, lastIndex, arr) {
  Contract$WonderLog.requireCheck((function (param) {
          var len = arr.length;
          return Contract$WonderLog.test(Log$WonderLog.buildAssertMessage("lastIndex:" + (String(lastIndex) + (" === arr.length:" + (String(len) + ""))), "not"), (function (param) {
                        return Contract$WonderLog.assertEqual(/* Int */0, arr.length - 1 | 0, lastIndex);
                      }));
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  arr[index] = arr[lastIndex];
  arr.pop();
  return /* () */0;
}

function range(a, b) {
  var result = ArrayService$WonderCommonlib.createEmpty(/* () */0);
  for(var i = a; i <= b; ++i){
    result.push(i);
  }
  return result;
}

function rangeReverse(a, b) {
  var result = ArrayService$WonderCommonlib.createEmpty(/* () */0);
  for(var i = a; i >= b; --i){
    result.push(i);
  }
  return result;
}

function join(arr) {
  var output = "";
  for(var i = 0 ,i_finish = arr.length; i <= i_finish; ++i){
    output = output + Caml_array.caml_array_get(arr, i);
  }
  return output;
}

function push(item, arr) {
  arr.push(item);
  return arr;
}

function hasItem(arr) {
  return arr.length > 0;
}

function unsafeGetFirst(arr) {
  return arr[0];
}

function removeSpecificItem(target, array) {
  return array.filter((function (item) {
                return Caml_obj.caml_notequal(item, target);
              }));
}

function getFirst(arr) {
  return Caml_option.nullable_to_opt(arr[0]);
}

function unsafeFindFirst(arr, targetValue, func) {
  return Contract$WonderLog.ensureCheck((function (first) {
                var arrJson = Log$WonderLog.getJsonStr(arr);
                return Contract$WonderLog.test(Log$WonderLog.buildAssertMessage("find " + (String(targetValue) + (" in " + (String(arrJson) + ""))), "not"), (function (param) {
                              return Contract$WonderLog.assertNullableExist(first);
                            }));
              }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData), arr.find(func));
}

function findFirst(arr, targetValue, func) {
  return Caml_option.undefined_to_opt(arr.find(Curry.__1(func)));
}

function unsafeGetLast(arr) {
  return arr[arr.length - 1 | 0];
}

function getLast(arr) {
  return Caml_option.nullable_to_opt(unsafeGetLast(arr));
}

function getNth(index, arr) {
  return Caml_option.nullable_to_opt(arr[index]);
}

function removeDuplicateItems(buildKeyFunc, arr) {
  var resultArr = /* array */[];
  var map = MutableHashMapService$WonderCommonlib.createEmpty(/* () */0);
  for(var i = 0 ,i_finish = arr.length - 1 | 0; i <= i_finish; ++i){
    var item = arr[i];
    var key = buildKeyFunc(item);
    var match = MutableHashMapService$WonderCommonlib.get(key, map);
    if (match === undefined) {
      resultArr.push(item);
      MutableHashMapService$WonderCommonlib.set(key, item, map);
    }
    
  }
  return resultArr;
}

function hasDuplicateItems(buildKeyFunc, arr) {
  return ArrayService$WonderCommonlib.reduceOneParam((function (param, item) {
                  var map = param[1];
                  if (param[0]) {
                    return /* tuple */[
                            true,
                            map
                          ];
                  } else {
                    var key = buildKeyFunc(item);
                    var match = ImmutableHashMapService$WonderCommonlib.get(key, map);
                    if (match !== undefined) {
                      return /* tuple */[
                              true,
                              map
                            ];
                    } else {
                      return /* tuple */[
                              false,
                              ImmutableHashMapService$WonderCommonlib.set(key, item, map)
                            ];
                    }
                  }
                }), /* tuple */[
                false,
                ImmutableHashMapService$WonderCommonlib.createEmpty(/* () */0)
              ], arr)[0];
}

function isNotValid(value) {
  if (value === null) {
    return true;
  } else {
    return value === undefined;
  }
}

function reduceOneParamValidi(func, param, arr) {
  var mutableParam = param;
  for(var i = 0 ,i_finish = arr.length - 1 | 0; i <= i_finish; ++i){
    var value = arr[i];
    if (!isNotValid(value)) {
      mutableParam = func(mutableParam, arr[i], i);
    }
    
  }
  return mutableParam;
}

function fastConcat(arr1, arr2) {
  return ArrayService$WonderCommonlib.reduceOneParam((function (arr1, value2) {
                return push(value2, arr1);
              }), arr1, arr2);
}

function _includeInSourceArr(targetItem, resultArr, _param) {
  while(true) {
    var param = _param;
    var sourceArrLength = param[2];
    var sourceArr = param[1];
    var posInSourceArr = param[0];
    var sourceItem = sourceArr[posInSourceArr];
    var match = posInSourceArr >= sourceArrLength;
    if (match) {
      return /* tuple */[
              resultArr,
              0
            ];
    } else {
      var match$1 = sourceItem !== targetItem;
      if (match$1) {
        _param = /* tuple */[
          posInSourceArr + 1 | 0,
          sourceArr,
          sourceArrLength
        ];
        continue ;
      } else {
        return /* tuple */[
                push(sourceItem, resultArr),
                posInSourceArr + 1 | 0
              ];
      }
    }
  };
}

function _excludeInSourceArr(targetItem, _resultArr, _param) {
  while(true) {
    var param = _param;
    var resultArr = _resultArr;
    var sourceArr = param[1];
    var posInSourceArr = param[0];
    var sourceItem = sourceArr[posInSourceArr];
    var match = sourceItem === targetItem;
    if (match) {
      return /* tuple */[
              resultArr,
              posInSourceArr + 1 | 0
            ];
    } else {
      _param = /* tuple */[
        posInSourceArr + 1 | 0,
        sourceArr,
        param[2]
      ];
      _resultArr = push(sourceItem, resultArr);
      continue ;
    }
  };
}

function _fastHandleRelation(param, param$1) {
  var handleInSourceArrFunc = param$1[1];
  var sourceArr = param[1];
  var targetArr = param[0];
  Contract$WonderLog.requireCheck((function (param) {
          return Contract$WonderLog.test(Log$WonderLog.buildAssertMessage("targetArr\'s length <= sourceArr\'s length", "not"), (function (param) {
                        return Contract$WonderLog.Operators[/* <= */11](targetArr.length, sourceArr.length);
                      }));
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  var match = targetArr.length === sourceArr.length;
  if (match) {
    Contract$WonderLog.requireCheck((function (param) {
            return Contract$WonderLog.test(Log$WonderLog.buildAssertMessage("targetArr == sourceArr", "not"), (function (param) {
                          return Contract$WonderLog.assertTrue(Caml_obj.caml_equal(targetArr.slice().sort((function (a, b) {
                                                return a - b | 0;
                                              })), sourceArr.slice().sort((function (a, b) {
                                                return a - b | 0;
                                              }))));
                        }));
          }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
    return Curry._2(param$1[0], targetArr, sourceArr);
  } else {
    sourceArr.sort((function (a, b) {
            return a - b | 0;
          }));
    targetArr.sort((function (a, b) {
            return a - b | 0;
          }));
    var sourceArrLength = sourceArr.length;
    var match$1 = ArrayService$WonderCommonlib.reduceOneParam((function (param, targetItem) {
            return Curry._3(handleInSourceArrFunc, targetItem, param[0], /* tuple */[
                        param[1],
                        sourceArr,
                        sourceArrLength
                      ]);
          }), /* tuple */[
          /* array */[],
          0
        ], targetArr);
    return Curry._3(param$1[2], match$1[1], sourceArr, match$1[0]);
  }
}

function fastExclude(targetArr, sourceArr) {
  return _fastHandleRelation(/* tuple */[
              targetArr,
              sourceArr
            ], /* tuple */[
              (function (param, param$1) {
                  return /* array */[];
                }),
              _excludeInSourceArr,
              (function (posInSourceArr, sourceArr, resultArr) {
                  return fastConcat(resultArr, sourceArr.slice(posInSourceArr));
                })
            ]);
}

function fastIntersect(targetArr, sourceArr) {
  return _fastHandleRelation(/* tuple */[
              targetArr,
              sourceArr
            ], /* tuple */[
              (function (targetArr, param) {
                  return targetArr;
                }),
              _includeInSourceArr,
              (function (posInSourceArr, sourceArr, resultArr) {
                  return resultArr;
                })
            ]);
}

var batchRemove = fastExclude;

function addUniqueItem(target, array) {
  return removeDuplicateItems((function (item) {
                return item;
              }), push(target, array.slice()));
}

exports.deleteBySwap = deleteBySwap;
exports.range = range;
exports.rangeReverse = rangeReverse;
exports.join = join;
exports.push = push;
exports.hasItem = hasItem;
exports.unsafeGetFirst = unsafeGetFirst;
exports.removeSpecificItem = removeSpecificItem;
exports.getFirst = getFirst;
exports.unsafeFindFirst = unsafeFindFirst;
exports.findFirst = findFirst;
exports.unsafeGetLast = unsafeGetLast;
exports.getLast = getLast;
exports.getNth = getNth;
exports.removeDuplicateItems = removeDuplicateItems;
exports.hasDuplicateItems = hasDuplicateItems;
exports.isNotValid = isNotValid;
exports.reduceOneParamValidi = reduceOneParamValidi;
exports.fastConcat = fastConcat;
exports._includeInSourceArr = _includeInSourceArr;
exports._excludeInSourceArr = _excludeInSourceArr;
exports._fastHandleRelation = _fastHandleRelation;
exports.fastExclude = fastExclude;
exports.fastIntersect = fastIntersect;
exports.batchRemove = batchRemove;
exports.addUniqueItem = addUniqueItem;
/* Log-WonderLog Not a pure module */