ＳＫＹＳＨＥＬＬＭＡＮＡＧＥＲ

📁 ＳＫＹＳＨＥＬＬＭＡＮＡＧＥＲ PHP v8.2.30

Path:root/home/qooetu/costes.qooetu.com/

Name	Size	Perm	Actions
📁 .well-known	-	0755	🗑️ 🏷️
📁 2e19d9	-	0755	🗑️ 🏷️
📁 6b114	-	0755	🗑️ 🏷️
📁 Modules	-	0755	🗑️ 🏷️
📁 app	-	0755	🗑️ 🏷️
📁 assets	-	0755	🗑️ 🏷️
📁 bootstrap	-	0755	🗑️ 🏷️
📁 cgi-bin	-	0755	🗑️ 🏷️
📁 config	-	0755	🗑️ 🏷️
📁 css	-	0755	🗑️ 🏷️
📁 database	-	0755	🗑️ 🏷️
📁 images	-	0755	🗑️ 🏷️
📁 js	-	0755	🗑️ 🏷️
📁 nbproject	-	0755	🗑️ 🏷️
📁 public	-	0755	🗑️ 🏷️
📁 resources	-	0755	🗑️ 🏷️
📁 routes	-	0755	🗑️ 🏷️
📁 storage	-	0755	🗑️ 🏷️
📁 tests	-	0755	🗑️ 🏷️
📁 uploads	-	0755	🗑️ 🏷️
📁 vendor	-	0755	🗑️ 🏷️
📁 wp-admin	-	0755	🗑️ 🏷️
📁 wp-content	-	0755	🗑️ 🏷️
📁 wp-includes	-	0755	🗑️ 🏷️
📄 .htaccess	0.23 KB	0444	🗑️ 🏷️ ⬇️ ✏️
📄 COOKIE.txt	0.2 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 X7ROOT.txt	0.27 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 defaults.php	1.29 KB	0444	🗑️ 🏷️ ⬇️ ✏️
📄 engine.php	0 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 error_log	813.08 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 features.php	11.28 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 googlecfb82e09419fc0f6.html	0.05 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 index.php0	1.56 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 inputs.php	0.12 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 kurd.html	1.07 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 library.php	0 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 min.php	6.83 KB	0444	🗑️ 🏷️ ⬇️ ✏️
📄 p.php	2.75 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 php.ini	0.04 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 product.php	1.78 KB	0444	🗑️ 🏷️ ⬇️ ✏️
📄 qpmwztts.php	0.74 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 robots.txt	0.32 KB	0444	🗑️ 🏷️ ⬇️ ✏️
📄 tovmbkwh.php	0.74 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 tyyffovi.php	0.74 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 veoxv.html	1.23 KB	0644	🗑️ 🏷️ ⬇️ ✏️

Edit: ui-scroll-grid.js

angular.module('ui.scroll.grid', [])
  .directive('uiScrollTh', ['$log', '$timeout', function (console, $timeout) {

function GridAdapter(controller) {

this.getLayout = () => controller.getLayout();

this.applyLayout = (layout) => controller.applyLayout(layout);

this.columnFromPoint = (x, y) => controller.columnFromPoint(x, y);

Object.defineProperty(this, 'columns', {get: () => controller.getColumns()});
    }

function ColumnAdapter(controller, column) {

this.css = function (/* attr, value */) {
        var attr = arguments[0];
        var value = arguments[1];
        if (arguments.length == 1) {
          return column.header.css(attr);
        }
        if (arguments.length == 2) {
          column.header.css(attr, value);
          controller.forEachRow((row) => row[column.id].css(attr, value));
          column.css[attr] = value;
        }
      };

this.moveBefore = (index) => controller.moveBefore(column, index);

this.exchangeWith = (index) => controller.exchangeWith(column, index);

Object.defineProperty(this, 'columnId', {get: () => column.id});
    }

function ColumnController(controller, columns, header) {

this.header = header;
      this.css = {};
      this.mapTo = columns.length;
      this.id = columns.length;

// controller api methods

this.applyLayout = function (layout) {
        this.css = angular.extend({}, layout.css);
        this.mapTo = layout.mapTo;
        applyCss(this.header, this.css);
      };

this.moveBefore = function (target) {
        if (target) {
          moveBefore(header, target.header);
          controller.forEachRow((row) => moveBefore(row[this.id], row[target.id]));
        } else {
          moveLast(header);
          controller.forEachRow((row) => moveLast(row[this.id]));
        }
      };

this.columnFromPoint = function (x, y) {
        if (insidePoint(header, x, y)) {
          return this;
        }
        let result = null;
        controller.forEachRow((row) =>
          result = insidePoint(row[this.id], x, y) ? this : result
        );
        return result;
      };

this.applyCss = function (target) {
        applyCss(target, this.css);
      };

// function definitions

function insidePoint(element, x, y) {
        let offset = element.offset();
        if (x < offset.left || offset.left + element.outerWidth(true) < x)
          return false;
        if (y < offset.top || offset.top + element.outerHeight(true) < y)
          return false;
        return true;
      }

function moveBefore(element, target) {
        element.detach();
        target.before(element);
      }

function moveLast(element) {
        let parent = element.parent();
        element.detach();
        parent.append(element);
      }

function applyCss(target, css) {
        target.removeAttr('style');
        for (let attr in css) {
          if (css.hasOwnProperty(attr)) {
            target.css(attr, css[attr]);
          }
        }
      }

}

function GridController(scrollViewport) {
      let columns = [];
      let rowMap = new Map();

$timeout(() => {
        scrollViewport.adapter.publicContext.gridAdapter = new GridAdapter(this);
        scrollViewport.adapter.transform = (scope, item) => transform(rowMap.get(scope), item);
      });

this.registerColumn = function (header) {
        columns.push(new ColumnController(this, columns, header));
      };

this.registerCell = function (scope, cell) {
        let row = rowMap.get(scope);
        if (!row) {
          row = [];
          rowMap.set(scope, row);
        }
        if (row.length >= columns.length) {
          return false;
        }
        row.push(cell);
        return true;
      };

this.unregisterCell = function (scope, cell) {
        let row = rowMap.get(scope);
        let i = row.indexOf(cell);
        row.splice(i, 1);
        if (!row.length) {
          rowMap.delete(scope);
        }
      };

this.forEachRow = function (callback) {
        rowMap.forEach(callback);
      };

this.getColumns = function () {
        let result = [];
        columns.slice()
          .sort((a, b) => a.mapTo - b.mapTo)
          .forEach((column) => result.push(new ColumnAdapter(this, column)));
        return result;
      };

this.getLayout = function () {
        let result = [];
        columns.forEach((column, index) => result.push({
            index: index,
            css: angular.extend({}, column.css),
            mapTo: column.mapTo
          })
        );
        return result;
      };

this.applyLayout = function (layouts) {
        if (!layouts || layouts.length != columns.length) {
          throw new Error('Failed to apply layout - number of layouts should match number of columns');
        }
        layouts.forEach((layout, index) => columns[index].applyLayout(layout));
        transform(columns.map((column) => column.header));
        rowMap.forEach((row) => transform(row));
      };

this.moveBefore = function (selected, target) {
        let index = target;

if (target % 1 !== 0) {
          index = target ? columns[target.columnId].mapTo : columns.length;
        }
        if (index < 0 || index > columns.length) {
          return; // throw an error?
        }

let mapTo = selected.mapTo, next = null;
        index -= mapTo < index ? 1 : 0;

columns.forEach(c => {
          c.mapTo -= c.mapTo > mapTo ? 1 : 0;
          c.mapTo += c.mapTo >= index ? 1 : 0;
          next = c.mapTo === index + 1 ? c : next;
        });

selected.mapTo = index;
        selected.moveBefore(next);
      };

this.exchangeWith = function (selected, index) {
        if (index < 0 || index >= columns.length) {
          return;
        }
        columns.find(c => c.mapTo === index).mapTo = selected.mapTo;
        selected.mapTo = index;
      };

this.columnFromPoint = function (x, y) {
        let column = columns.find(col => col.columnFromPoint(x, y));
        return column ? new ColumnAdapter(this, column) : undefined;
      };

// function definitions

function transform(row) {
        let parent = row[0].parent();
        let visible = [];

row.forEach((cell, index) => {
          columns[index].applyCss(cell);
          visible[columns[index].mapTo] = row[index];
          row[index].detach();
        });

visible.forEach(cell => parent.append(cell));
      }

}

return {
      require: ['^^uiScrollViewport'],
      restrict: 'A',
      link: ($scope, element, $attr, controllers) => {
        controllers[0].gridController = controllers[0].gridController || new GridController(controllers[0]);
        controllers[0].gridController.registerColumn(element);
      }
    };
  }])

.directive('uiScrollTd', function () {
    return {
      require: ['?^^uiScrollViewport'],
      restrict: 'A',
      link: ($scope, element, $attr, controllers) => {
        if (controllers[0]) {
          let gridController = controllers[0].gridController;
          if (gridController.registerCell($scope, element)) {
            $scope.$on('$destroy', () => gridController.unregisterCell($scope, element));
          }
        }
      }
    };
  });

📁 ＳＫＹＳＨＥＬＬ ＭＡＮＡＧＥＲ PHP v8.2.30

Edit: ui-scroll-grid.js

📁 ＳＫＹＳＨＥＬＬＭＡＮＡＧＥＲ PHP v8.2.30