diff options
-rw-r--r-- | .gitignore | 9 | ||||
-rw-r--r-- | .gitreview | 4 | ||||
-rw-r--r-- | LICENSE | 21 | ||||
-rw-r--r-- | MANIFEST.in | 3 | ||||
-rw-r--r-- | PKG-INFO | 25 | ||||
-rw-r--r-- | setup.cfg | 20 | ||||
-rw-r--r-- | setup.py | 28 | ||||
-rw-r--r-- | xstatic/pkg/angular_smart_table/__init__.py | 4 | ||||
-rw-r--r-- | xstatic/pkg/angular_smart_table/data/smart-table.js | 826 |
9 files changed, 504 insertions, 436 deletions
diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..b3085b8 --- /dev/null +++ b/.gitignore @@ -0,0 +1,9 @@ +*.pyc +*.sw? +*.sqlite3 +.DS_STORE +*.egg-info +.venv +.tox +build +dist diff --git a/.gitreview b/.gitreview new file mode 100644 index 0000000..b4f7935 --- /dev/null +++ b/.gitreview @@ -0,0 +1,4 @@ +[gerrit] +host=review.openstack.org +port=29418 +project=openstack/xstatic-angular-smart-table.git @@ -0,0 +1,21 @@ +Copyright (C) 2014 Laurent Renard. + +Permission is hereby granted, free of charge, to any person +obtaining a copy of this software and associated documentation files +(the "Software"), to deal in the Software without restriction, +including without limitation the rights to use, copy, modify, merge, +publish, distribute, sublicense, and/or sell copies of the Software, +and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS +BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/MANIFEST.in b/MANIFEST.in index c507fb4..af3cdd3 100644 --- a/MANIFEST.in +++ b/MANIFEST.in @@ -1,6 +1,5 @@ include README.txt -recursive-include xstatic/pkg/angular_smart_table * - +recursive-include xstatic * global-exclude *.pyc global-exclude *.pyo global-exclude *.orig diff --git a/PKG-INFO b/PKG-INFO deleted file mode 100644 index 53e78b9..0000000 --- a/PKG-INFO +++ /dev/null @@ -1,25 +0,0 @@ -Metadata-Version: 1.0 -Name: XStatic-smart-table -Version: 1.4.5.3 -Summary: smart-table 1.4.5 (XStatic packaging standard) -Home-page: https://github.com/lorenzofox3/Smart-Table -Author: Richard Jones -Author-email: r1chardj0n3s@gmail.com -License: (same as smart-table) -Description: - XStatic-smart-table - ------------------- - - smart-table javascript library packaged for setuptools (easy_install) / pip. - - This package is intended to be used by **any** project that needs these files. - - It intentionally does **not** provide any extra code except some metadata - **nor** has any extra requirements. You MAY use some minimal support code from - the XStatic base package, if you like. - - You can find more info about the xstatic packaging way in the package - `XStatic`. - -Keywords: smart-table angular table angular_smart_table xstatic -Platform: any diff --git a/setup.cfg b/setup.cfg new file mode 100644 index 0000000..fe4580e --- /dev/null +++ b/setup.cfg @@ -0,0 +1,20 @@ +[metadata] +name = XStatic-smart-table +summary = smart-table 1.4.13 (XStatic packaging standard) +description-file = README.rst +maintainer = Richard Jones +maintainer-email = r1chardj0n3s@gmail.com +home-page = https://github.com/lorenzofox3/Smart-Table +keywords = smart-table angular table angular_smart_table xstatic +license = (same as smart-table) +zip_safe = False +namespace_packages = + xstatic + xstatic.pkg + +[files] +packages = + xstatic + +[bdist_wheel] +universal = True @@ -1,27 +1,17 @@ - -from xstatic.pkg import angular_smart_table as xs +from setuptools import setup, find_packages # The README.txt file should be written in reST so that PyPI can use # it to generate your project's PyPI page. long_description = open('README.txt').read() -from setuptools import setup, find_packages - setup( - name=xs.PACKAGE_NAME, - version=xs.PACKAGE_VERSION, - description=xs.DESCRIPTION, - long_description=long_description, - classifiers=xs.CLASSIFIERS, - keywords=xs.KEYWORDS, - maintainer=xs.MAINTAINER, - maintainer_email=xs.MAINTAINER_EMAIL, - license=xs.LICENSE, - url=xs.HOMEPAGE, - platforms=xs.PLATFORMS, + name='XStatic-smart-table', + summary="""smart-table 1.4.13 (XStatic packaging standard)""", + description=long_description, + maintainer="Richard Jones", + maintainer_email='r1chardj0n3s@gmail.com', + use_scm_version=True, + setup_requires=['setuptools_scm', 'wheel'], packages=find_packages(), - namespace_packages=['xstatic', 'xstatic.pkg', ], - include_package_data=True, - zip_safe=False, - install_requires=[], + include_package_data=True ) diff --git a/xstatic/pkg/angular_smart_table/__init__.py b/xstatic/pkg/angular_smart_table/__init__.py index 32aec65..fd0a5af 100644 --- a/xstatic/pkg/angular_smart_table/__init__.py +++ b/xstatic/pkg/angular_smart_table/__init__.py @@ -15,9 +15,9 @@ NAME = __name__.split('.')[-1] # package name (e.g. 'foo' or 'foo_bar') # please use a all-lowercase valid python # package name -VERSION = '1.4.5' # version of the packaged files, please use the upstream +VERSION = '1.4.13' # version of the packaged files, please use the upstream # version number -BUILD = '3' # our package build number, so we can release new builds +BUILD = '0' # our package build number, so we can release new builds # with fixes for xstatic stuff. PACKAGE_VERSION = VERSION + '.' + BUILD # version used for PyPi diff --git a/xstatic/pkg/angular_smart_table/data/smart-table.js b/xstatic/pkg/angular_smart_table/data/smart-table.js index d5cd473..9faa7d4 100644 --- a/xstatic/pkg/angular_smart_table/data/smart-table.js +++ b/xstatic/pkg/angular_smart_table/data/smart-table.js @@ -1,5 +1,5 @@ /** -* @version 1.4.5 +* @version 1.4.13 * @license MIT */ (function (ng, undefined){ @@ -7,416 +7,466 @@ ng.module('smart-table', []).run(['$templateCache', function ($templateCache) { $templateCache.put('template/smart-table/pagination.html', - '<div class="pagination" ng-if="pages.length >= 2"><ul class="pagination">' + + '<nav ng-if="pages.length >= 2"><ul class="pagination">' + '<li ng-repeat="page in pages" ng-class="{active: page==currentPage}"><a ng-click="selectPage(page)">{{page}}</a></li>' + - '</ul></div>'); + '</ul></nav>'); }]); ng.module('smart-table') - .controller('stTableController', ['$scope', '$parse', '$filter', '$attrs', function StTableController($scope, $parse, $filter, $attrs) { - var propertyName = $attrs.stTable; - var displayGetter = $parse(propertyName); - var displaySetter = displayGetter.assign; - var safeGetter; - var orderBy = $filter('orderBy'); - var filter = $filter('filter'); - var safeCopy = copyRefs(displayGetter($scope)); - var tableState = { - sort: {}, - search: {}, - pagination: { - start: 0 - } - }; - var pipeAfterSafeCopy = true; - var ctrl = this; - var lastSelected; - - function copyRefs(src) { - return [].concat(src); + .constant('stConfig', { + pagination: { + template: 'template/smart-table/pagination.html', + itemsByPage: 10, + displayedPages: 5 + }, + search: { + delay: 400 // ms + }, + select: { + mode: 'single', + selectedClass: 'st-selected' + }, + sort: { + ascentClass: 'st-sort-ascent', + descentClass: 'st-sort-descent' + } + }); +ng.module('smart-table') + .controller('stTableController', ['$scope', '$parse', '$filter', '$attrs', function StTableController ($scope, $parse, $filter, $attrs) { + var propertyName = $attrs.stTable; + var displayGetter = $parse(propertyName); + var displaySetter = displayGetter.assign; + var safeGetter; + var orderBy = $filter('orderBy'); + var filter = $filter('filter'); + var safeCopy = copyRefs(displayGetter($scope)); + var tableState = { + sort: {}, + search: {}, + pagination: { + start: 0 + } + }; + var filtered; + var pipeAfterSafeCopy = true; + var ctrl = this; + var lastSelected; + + function copyRefs (src) { + return src ? [].concat(src) : []; + } + + function updateSafeCopy () { + safeCopy = copyRefs(safeGetter($scope)); + if (pipeAfterSafeCopy === true) { + ctrl.pipe(); + } + } + + if ($attrs.stSafeSrc) { + safeGetter = $parse($attrs.stSafeSrc); + $scope.$watch(function () { + var safeSrc = safeGetter($scope); + return safeSrc ? safeSrc.length : 0; + + }, function (newValue, oldValue) { + if (newValue !== safeCopy.length) { + updateSafeCopy(); } - - function updateSafeCopy() { - safeCopy = copyRefs(safeGetter($scope)); - if (pipeAfterSafeCopy === true) { - ctrl.pipe(); - } + }); + $scope.$watch(function () { + return safeGetter($scope); + }, function (newValue, oldValue) { + if (newValue !== oldValue) { + updateSafeCopy(); } - - if ($attrs.stSafeSrc) { - safeGetter = $parse($attrs.stSafeSrc); - $scope.$watch(function () { - var safeSrc = safeGetter($scope); - return safeSrc ? safeSrc.length : 0; - - }, function (newValue, oldValue) { - if (newValue !== safeCopy.length) { - updateSafeCopy(); - } - }); - $scope.$watch(function () { - return safeGetter($scope); - }, function (newValue, oldValue) { - if (newValue !== oldValue) { - updateSafeCopy(); - } - }); + }); + } + + /** + * sort the rows + * @param {Function | String} predicate - function or string which will be used as predicate for the sorting + * @param [reverse] - if you want to reverse the order + */ + this.sortBy = function sortBy (predicate, reverse) { + tableState.sort.predicate = predicate; + tableState.sort.reverse = reverse === true; + + if (ng.isFunction(predicate)) { + tableState.sort.functionName = predicate.name; + } else { + delete tableState.sort.functionName; + } + + tableState.pagination.start = 0; + return this.pipe(); + }; + + /** + * search matching rows + * @param {String} input - the input string + * @param {String} [predicate] - the property name against you want to check the match, otherwise it will search on all properties + */ + this.search = function search (input, predicate) { + var predicateObject = tableState.search.predicateObject || {}; + var prop = predicate ? predicate : '$'; + + input = ng.isString(input) ? input.trim() : input; + predicateObject[prop] = input; + // to avoid to filter out null value + if (!input) { + delete predicateObject[prop]; + } + tableState.search.predicateObject = predicateObject; + tableState.pagination.start = 0; + return this.pipe(); + }; + + /** + * this will chain the operations of sorting and filtering based on the current table state (sort options, filtering, ect) + */ + this.pipe = function pipe () { + var pagination = tableState.pagination; + var output; + filtered = tableState.search.predicateObject ? filter(safeCopy, tableState.search.predicateObject) : safeCopy; + if (tableState.sort.predicate) { + filtered = orderBy(filtered, tableState.sort.predicate, tableState.sort.reverse); + } + if (pagination.number !== undefined) { + pagination.numberOfPages = filtered.length > 0 ? Math.ceil(filtered.length / pagination.number) : 1; + pagination.start = pagination.start >= filtered.length ? (pagination.numberOfPages - 1) * pagination.number : pagination.start; + output = filtered.slice(pagination.start, pagination.start + parseInt(pagination.number)); + } + displaySetter($scope, output || filtered); + }; + + /** + * select a dataRow (it will add the attribute isSelected to the row object) + * @param {Object} row - the row to select + * @param {String} [mode] - "single" or "multiple" (multiple by default) + */ + this.select = function select (row, mode) { + var rows = safeCopy; + var index = rows.indexOf(row); + if (index !== -1) { + if (mode === 'single') { + row.isSelected = row.isSelected !== true; + if (lastSelected) { + lastSelected.isSelected = false; + } + lastSelected = row.isSelected === true ? row : undefined; + } else { + rows[index].isSelected = !rows[index].isSelected; + } + } + }; + + /** + * take a slice of the current sorted/filtered collection (pagination) + * + * @param {Number} start - start index of the slice + * @param {Number} number - the number of item in the slice + */ + this.slice = function splice (start, number) { + tableState.pagination.start = start; + tableState.pagination.number = number; + return this.pipe(); + }; + + /** + * return the current state of the table + * @returns {{sort: {}, search: {}, pagination: {start: number}}} + */ + this.tableState = function getTableState () { + return tableState; + }; + + this.getFilteredCollection = function getFilteredCollection () { + return filtered || safeCopy; + }; + + /** + * Use a different filter function than the angular FilterFilter + * @param filterName the name under which the custom filter is registered + */ + this.setFilterFunction = function setFilterFunction (filterName) { + filter = $filter(filterName); + }; + + /** + * Use a different function than the angular orderBy + * @param sortFunctionName the name under which the custom order function is registered + */ + this.setSortFunction = function setSortFunction (sortFunctionName) { + orderBy = $filter(sortFunctionName); + }; + + /** + * Usually when the safe copy is updated the pipe function is called. + * Calling this method will prevent it, which is something required when using a custom pipe function + */ + this.preventPipeOnWatch = function preventPipe () { + pipeAfterSafeCopy = false; + }; + }]) + .directive('stTable', function () { + return { + restrict: 'A', + controller: 'stTableController', + link: function (scope, element, attr, ctrl) { + + if (attr.stSetFilter) { + ctrl.setFilterFunction(attr.stSetFilter); } - /** - * sort the rows - * @param {Function | String} predicate - function or string which will be used as predicate for the sorting - * @param [reverse] - if you want to reverse the order - */ - this.sortBy = function sortBy(predicate, reverse) { - tableState.sort.predicate = predicate; - tableState.sort.reverse = reverse === true; - tableState.pagination.start = 0; - return this.pipe(); - }; - - /** - * search matching rows - * @param {String} input - the input string - * @param {String} [predicate] - the property name against you want to check the match, otherwise it will search on all properties - */ - this.search = function search(input, predicate) { - var predicateObject = tableState.search.predicateObject || {}; - var prop = predicate ? predicate : '$'; - predicateObject[prop] = input; - // to avoid to filter out null value - if (!input) { - delete predicateObject[prop]; - } - tableState.search.predicateObject = predicateObject; - tableState.pagination.start = 0; - return this.pipe(); - }; + if (attr.stSetSort) { + ctrl.setSortFunction(attr.stSetSort); + } + } + }; + }); - /** - * this will chain the operations of sorting and filtering based on the current table state (sort options, filtering, ect) - */ - this.pipe = function pipe() { - var pagination = tableState.pagination; - var filtered = tableState.search.predicateObject ? filter(safeCopy, tableState.search.predicateObject) : safeCopy; - if (tableState.sort.predicate) { - filtered = orderBy(filtered, tableState.sort.predicate, tableState.sort.reverse); - } - if (pagination.number !== undefined) { - pagination.numberOfPages = filtered.length > 0 ? Math.ceil(filtered.length / pagination.number) : 1; - pagination.start = pagination.start >= filtered.length ? (pagination.numberOfPages - 1) * pagination.number : pagination.start; - filtered = filtered.slice(pagination.start, pagination.start + pagination.number); - } - displaySetter($scope, filtered); - }; +ng.module('smart-table') + .directive('stSearch', ['stConfig', '$timeout', function (stConfig, $timeout) { + return { + require: '^stTable', + scope: { + predicate: '=?stSearch' + }, + link: function (scope, element, attr, ctrl) { + var tableCtrl = ctrl; + var promise = null; + var throttle = attr.stDelay || stConfig.search.delay; + + scope.$watch('predicate', function (newValue, oldValue) { + if (newValue !== oldValue) { + ctrl.tableState().search = {}; + tableCtrl.search(element[0].value || '', newValue); + } + }); + + //table state -> view + scope.$watch(function () { + return ctrl.tableState().search; + }, function (newValue, oldValue) { + var predicateExpression = scope.predicate || '$'; + if (newValue.predicateObject && newValue.predicateObject[predicateExpression] !== element[0].value) { + element[0].value = newValue.predicateObject[predicateExpression] || ''; + } + }, true); + + // view -> table state + element.bind('input', function (evt) { + evt = evt.originalEvent || evt; + if (promise !== null) { + $timeout.cancel(promise); + } + promise = $timeout(function () { + tableCtrl.search(evt.target.value, scope.predicate || ''); + promise = null; + }, throttle); + }); + } + }; + }]); - /** - * select a dataRow (it will add the attribute isSelected to the row object) - * @param {Object} row - the row to select - * @param {String} [mode] - "single" or "multiple" (multiple by default) - */ - this.select = function select(row, mode) { - var rows = safeCopy; - var index = rows.indexOf(row); - if (index !== -1) { - if (mode === 'single') { - row.isSelected = row.isSelected !== true; - if (lastSelected) { - lastSelected.isSelected = false; - } - lastSelected = row.isSelected === true ? row : undefined; - } else { - rows[index].isSelected = !rows[index].isSelected; - } - } - }; +ng.module('smart-table') + .directive('stSelectRow', ['stConfig', function (stConfig) { + return { + restrict: 'A', + require: '^stTable', + scope: { + row: '=stSelectRow' + }, + link: function (scope, element, attr, ctrl) { + var mode = attr.stSelectMode || stConfig.select.mode; + element.bind('click', function () { + scope.$apply(function () { + ctrl.select(scope.row, mode); + }); + }); + + scope.$watch('row.isSelected', function (newValue) { + if (newValue === true) { + element.addClass(stConfig.select.selectedClass); + } else { + element.removeClass(stConfig.select.selectedClass); + } + }); + } + }; + }]); - /** - * take a slice of the current sorted/filtered collection (pagination) - * - * @param {Number} start - start index of the slice - * @param {Number} number - the number of item in the slice - */ - this.slice = function splice(start, number) { - tableState.pagination.start = start; - tableState.pagination.number = number; - return this.pipe(); - }; +ng.module('smart-table') + .directive('stSort', ['stConfig', '$parse', function (stConfig, $parse) { + return { + restrict: 'A', + require: '^stTable', + link: function (scope, element, attr, ctrl) { + + var predicate = attr.stSort; + var getter = $parse(predicate); + var index = 0; + var classAscent = attr.stClassAscent || stConfig.sort.ascentClass; + var classDescent = attr.stClassDescent || stConfig.sort.descentClass; + var stateClasses = [classAscent, classDescent]; + var sortDefault; + + if (attr.stSortDefault) { + sortDefault = scope.$eval(attr.stSortDefault) !== undefined ? scope.$eval(attr.stSortDefault) : attr.stSortDefault; + } - /** - * return the current state of the table - * @returns {{sort: {}, search: {}, pagination: {start: number}}} - */ - this.tableState = function getTableState() { - return tableState; - }; + //view --> table state + function sort () { + index++; + predicate = ng.isFunction(getter(scope)) ? getter(scope) : attr.stSort; + if (index % 3 === 0 && attr.stSkipNatural === undefined) { + //manual reset + index = 0; + ctrl.tableState().sort = {}; + ctrl.tableState().pagination.start = 0; + ctrl.pipe(); + } else { + ctrl.sortBy(predicate, index % 2 === 0); + } + } - /** - * Use a different filter function than the angular FilterFilter - * @param filterName the name under which the custom filter is registered - */ - this.setFilterFunction = function setFilterFunction(filterName) { - filter = $filter(filterName); - }; + element.bind('click', function sortClick () { + if (predicate) { + scope.$apply(sort); + } + }); - /** - *User a different function than the angular orderBy - * @param sortFunctionName the name under which the custom order function is registered - */ - this.setSortFunction = function setSortFunction(sortFunctionName) { - orderBy = $filter(sortFunctionName); - }; + if (sortDefault) { + index = sortDefault === 'reverse' ? 1 : 0; + sort(); + } - /** - * Usually when the safe copy is updated the pipe function is called. - * Calling this method will prevent it, which is something required when using a custom pipe function - */ - this.preventPipeOnWatch = function preventPipe() { - pipeAfterSafeCopy = false; - }; - }]) - .directive('stTable', function () { - return { - restrict: 'A', - controller: 'stTableController', - link: function (scope, element, attr, ctrl) { - - if (attr.stSetFilter) { - ctrl.setFilterFunction(attr.stSetFilter); - } - - if (attr.stSetSort) { - ctrl.setSortFunction(attr.stSetSort); - } - } - }; - }); + //table state --> view + scope.$watch(function () { + return ctrl.tableState().sort; + }, function (newValue) { + if (newValue.predicate !== predicate) { + index = 0; + element + .removeClass(classAscent) + .removeClass(classDescent); + } else { + index = newValue.reverse === true ? 2 : 1; + element + .removeClass(stateClasses[index % 2]) + .addClass(stateClasses[index - 1]); + } + }, true); + } + }; + }]); ng.module('smart-table') - .directive('stSearch', ['$timeout', function ($timeout) { - return { - require: '^stTable', - scope: { - predicate: '=?stSearch' - }, - link: function (scope, element, attr, ctrl) { - var tableCtrl = ctrl; - var promise = null; - var throttle = attr.stDelay || 400; - - scope.$watch('predicate', function (newValue, oldValue) { - if (newValue !== oldValue) { - ctrl.tableState().search = {}; - tableCtrl.search(element[0].value || '', newValue); - } - }); - - //table state -> view - scope.$watch(function () { - return ctrl.tableState().search; - }, function (newValue, oldValue) { - var predicateExpression = scope.predicate || '$'; - if (newValue.predicateObject && newValue.predicateObject[predicateExpression] !== element[0].value) { - element[0].value = newValue.predicateObject[predicateExpression] || ''; - } - }, true); - - // view -> table state - element.bind('input', function (evt) { - evt = evt.originalEvent || evt; - if (promise !== null) { - $timeout.cancel(promise); - } - promise = $timeout(function () { - tableCtrl.search(evt.target.value, scope.predicate || ''); - promise = null; - }, throttle); - }); - } - }; - }]); + .directive('stPagination', ['stConfig', function (stConfig) { + return { + restrict: 'EA', + require: '^stTable', + scope: { + stItemsByPage: '=?', + stDisplayedPages: '=?', + stPageChange: '&' + }, + templateUrl: function (element, attrs) { + if (attrs.stTemplate) { + return attrs.stTemplate; + } + return stConfig.pagination.template; + }, + link: function (scope, element, attrs, ctrl) { + + scope.stItemsByPage = scope.stItemsByPage ? +(scope.stItemsByPage) : stConfig.pagination.itemsByPage; + scope.stDisplayedPages = scope.stDisplayedPages ? +(scope.stDisplayedPages) : stConfig.pagination.displayedPages; + + scope.currentPage = 1; + scope.pages = []; + + function redraw () { + var paginationState = ctrl.tableState().pagination; + var start = 1; + var end; + var i; + var prevPage = scope.currentPage; + scope.currentPage = Math.floor(paginationState.start / paginationState.number) + 1; + + start = Math.max(start, scope.currentPage - Math.abs(Math.floor(scope.stDisplayedPages / 2))); + end = start + scope.stDisplayedPages; + + if (end > paginationState.numberOfPages) { + end = paginationState.numberOfPages + 1; + start = Math.max(1, end - scope.stDisplayedPages); + } + + scope.pages = []; + scope.numPages = paginationState.numberOfPages; + + for (i = start; i < end; i++) { + scope.pages.push(i); + } + + if (prevPage !== scope.currentPage) { + scope.stPageChange({newPage: scope.currentPage}); + } + } -ng.module('smart-table') - .directive('stSelectRow', function () { - return { - restrict: 'A', - require: '^stTable', - scope: { - row: '=stSelectRow' - }, - link: function (scope, element, attr, ctrl) { - var mode = attr.stSelectMode || 'single'; - element.bind('click', function () { - scope.$apply(function () { - ctrl.select(scope.row, mode); - }); - }); - - scope.$watch('row.isSelected', function (newValue, oldValue) { - if (newValue === true) { - element.addClass('st-selected'); - } else { - element.removeClass('st-selected'); - } - }); - } + //table state --> view + scope.$watch(function () { + return ctrl.tableState().pagination; + }, redraw, true); + + //scope --> table state (--> view) + scope.$watch('stItemsByPage', function (newValue, oldValue) { + if (newValue !== oldValue) { + scope.selectPage(1); + } + }); + + scope.$watch('stDisplayedPages', redraw); + + //view -> table state + scope.selectPage = function (page) { + if (page > 0 && page <= scope.numPages) { + ctrl.slice((page - 1) * scope.stItemsByPage, scope.stItemsByPage); + } }; - }); -ng.module('smart-table') - .directive('stSort', ['$parse', function ($parse) { - return { - restrict: 'A', - require: '^stTable', - link: function (scope, element, attr, ctrl) { - - var predicate = attr.stSort; - var getter = $parse(predicate); - var index = 0; - var classAscent = attr.stClassAscent || 'st-sort-ascent'; - var classDescent = attr.stClassDescent || 'st-sort-descent'; - var stateClasses = [classAscent, classDescent]; - - //view --> table state - function sort() { - index++; - if (index % 3 === 0 && attr.stSkipNatural === undefined) { - //manual reset - index = 0; - ctrl.tableState().sort = {}; - ctrl.tableState().pagination.start = 0; - ctrl.pipe(); - } else { - ctrl.sortBy(predicate, index % 2 === 0); - } - } - - if (ng.isFunction(getter(scope))) { - predicate = getter(scope); - } - - element.bind('click', function sortClick() { - if (predicate) { - scope.$apply(sort); - } - }); - - if (attr.stSortDefault !== undefined) { - index = attr.stSortDefault === 'reverse' ? 1 : 0; - sort(); - } - - //table state --> view - scope.$watch(function () { - return ctrl.tableState().sort; - }, function (newValue) { - if (newValue.predicate !== predicate) { - index = 0; - element - .removeClass(classAscent) - .removeClass(classDescent); - } else { - index = newValue.reverse === true ? 2 : 1; - element - .removeClass(stateClasses[index % 2]) - .addClass(stateClasses[index - 1]); - } - }, true); - } - }; - }]); + if (!ctrl.tableState().pagination.number) { + ctrl.slice(0, scope.stItemsByPage); + } + } + }; + }]); ng.module('smart-table') - .directive('stPagination', function () { - return { - restrict: 'EA', - require: '^stTable', - scope: { - stItemsByPage: '=?', - stDisplayedPages: '=?' - }, - templateUrl: function(element, attrs) { - if (attrs.stTemplate) { - return attrs.stTemplate; - } - return 'template/smart-table/pagination.html'; - }, - link: function (scope, element, attrs, ctrl) { - - scope.stItemsByPage = scope.stItemsByPage ? +(scope.stItemsByPage) : 10; - scope.stDisplayedPages = scope.stDisplayedPages ? +(scope.stDisplayedPages) : 5; - - scope.currentPage = 1; - scope.pages = []; - - function redraw() { - var paginationState = ctrl.tableState().pagination; - var start = 1; - var end; - var i; - scope.currentPage = Math.floor(paginationState.start / paginationState.number) + 1; - - start = Math.max(start, scope.currentPage - Math.abs(Math.floor(scope.stDisplayedPages / 2))); - end = start + scope.stDisplayedPages; - - if (end > paginationState.numberOfPages) { - end = paginationState.numberOfPages + 1; - start = Math.max(1, end - scope.stDisplayedPages); - } - - scope.pages = []; - scope.numPages = paginationState.numberOfPages; - - for (i = start; i < end; i++) { - scope.pages.push(i); - } - } - - //table state --> view - scope.$watch(function () { - return ctrl.tableState().pagination; - }, redraw, true); - - //scope --> table state (--> view) - scope.$watch('stItemsByPage', function () { - scope.selectPage(1); - }); - - scope.$watch('stDisplayedPages', redraw); - - //view -> table state - scope.selectPage = function (page) { - if (page > 0 && page <= scope.numPages) { - ctrl.slice((page - 1) * scope.stItemsByPage, scope.stItemsByPage); - } - }; - - //select the first page - ctrl.slice(0, scope.stItemsByPage); + .directive('stPipe', function () { + return { + require: 'stTable', + scope: { + stPipe: '=' + }, + link: { + + pre: function (scope, element, attrs, ctrl) { + if (ng.isFunction(scope.stPipe)) { + ctrl.preventPipeOnWatch(); + ctrl.pipe = function () { + return scope.stPipe(ctrl.tableState(), ctrl); } - }; - }); + } + }, -ng.module('smart-table') - .directive('stPipe', function () { - return { - require: 'stTable', - scope: { - stPipe: '=' - }, - link: { - pre: function (scope, element, attrs, ctrl) { - - if (ng.isFunction(scope.stPipe)) { - ctrl.preventPipeOnWatch(); - ctrl.pipe = function () { - return scope.stPipe(ctrl.tableState(), ctrl); - } - } - } - } - }; - }); + post: function (scope, element, attrs, ctrl) { + ctrl.pipe(); + } + } + }; + }); -})(angular);
\ No newline at end of file +})(angular); +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["src/top.txt","src/smart-table.module.js","src/stConfig.js","src/stTable.js","src/stSearch.js","src/stSelectRow.js","src/stSort.js","src/stPagination.js","src/stPipe.js","src/bottom.txt"],"names":[],"mappings":"AAAA;AACA;AACA;ACFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AClMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC3CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AChEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC/EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACxBA","file":"smart-table.js","sourcesContent":["(function (ng, undefined){\n    'use strict';\n","ng.module('smart-table', []).run(['$templateCache', function ($templateCache) {\n    $templateCache.put('template/smart-table/pagination.html',\n        '<nav ng-if=\"pages.length >= 2\"><ul class=\"pagination\">' +\n        '<li ng-repeat=\"page in pages\" ng-class=\"{active: page==currentPage}\"><a ng-click=\"selectPage(page)\">{{page}}</a></li>' +\n        '</ul></nav>');\n}]);\n\n","ng.module('smart-table')\n  .constant('stConfig', {\n    pagination: {\n      template: 'template/smart-table/pagination.html',\n      itemsByPage: 10,\n      displayedPages: 5\n    },\n    search: {\n      delay: 400 // ms\n    },\n    select: {\n      mode: 'single',\n      selectedClass: 'st-selected'\n    },\n    sort: {\n      ascentClass: 'st-sort-ascent',\n      descentClass: 'st-sort-descent'\n    }\n  });","ng.module('smart-table')\n  .controller('stTableController', ['$scope', '$parse', '$filter', '$attrs', function StTableController ($scope, $parse, $filter, $attrs) {\n    var propertyName = $attrs.stTable;\n    var displayGetter = $parse(propertyName);\n    var displaySetter = displayGetter.assign;\n    var safeGetter;\n    var orderBy = $filter('orderBy');\n    var filter = $filter('filter');\n    var safeCopy = copyRefs(displayGetter($scope));\n    var tableState = {\n      sort: {},\n      search: {},\n      pagination: {\n        start: 0\n      }\n    };\n    var filtered;\n    var pipeAfterSafeCopy = true;\n    var ctrl = this;\n    var lastSelected;\n\n    function copyRefs (src) {\n      return src ? [].concat(src) : [];\n    }\n\n    function updateSafeCopy () {\n      safeCopy = copyRefs(safeGetter($scope));\n      if (pipeAfterSafeCopy === true) {\n        ctrl.pipe();\n      }\n    }\n\n    if ($attrs.stSafeSrc) {\n      safeGetter = $parse($attrs.stSafeSrc);\n      $scope.$watch(function () {\n        var safeSrc = safeGetter($scope);\n        return safeSrc ? safeSrc.length : 0;\n\n      }, function (newValue, oldValue) {\n        if (newValue !== safeCopy.length) {\n          updateSafeCopy();\n        }\n      });\n      $scope.$watch(function () {\n        return safeGetter($scope);\n      }, function (newValue, oldValue) {\n        if (newValue !== oldValue) {\n          updateSafeCopy();\n        }\n      });\n    }\n\n    /**\n     * sort the rows\n     * @param {Function | String} predicate - function or string which will be used as predicate for the sorting\n     * @param [reverse] - if you want to reverse the order\n     */\n    this.sortBy = function sortBy (predicate, reverse) {\n      tableState.sort.predicate = predicate;\n      tableState.sort.reverse = reverse === true;\n\n      if (ng.isFunction(predicate)) {\n        tableState.sort.functionName = predicate.name;\n      } else {\n        delete tableState.sort.functionName;\n      }\n\n      tableState.pagination.start = 0;\n      return this.pipe();\n    };\n\n    /**\n     * search matching rows\n     * @param {String} input - the input string\n     * @param {String} [predicate] - the property name against you want to check the match, otherwise it will search on all properties\n     */\n    this.search = function search (input, predicate) {\n      var predicateObject = tableState.search.predicateObject || {};\n      var prop = predicate ? predicate : '$';\n\n      input = ng.isString(input) ? input.trim() : input;\n      predicateObject[prop] = input;\n      // to avoid to filter out null value\n      if (!input) {\n        delete predicateObject[prop];\n      }\n      tableState.search.predicateObject = predicateObject;\n      tableState.pagination.start = 0;\n      return this.pipe();\n    };\n\n    /**\n     * this will chain the operations of sorting and filtering based on the current table state (sort options, filtering, ect)\n     */\n    this.pipe = function pipe () {\n      var pagination = tableState.pagination;\n      var output;\n      filtered = tableState.search.predicateObject ? filter(safeCopy, tableState.search.predicateObject) : safeCopy;\n      if (tableState.sort.predicate) {\n        filtered = orderBy(filtered, tableState.sort.predicate, tableState.sort.reverse);\n      }\n      if (pagination.number !== undefined) {\n        pagination.numberOfPages = filtered.length > 0 ? Math.ceil(filtered.length / pagination.number) : 1;\n        pagination.start = pagination.start >= filtered.length ? (pagination.numberOfPages - 1) * pagination.number : pagination.start;\n        output = filtered.slice(pagination.start, pagination.start + parseInt(pagination.number));\n      }\n      displaySetter($scope, output || filtered);\n    };\n\n    /**\n     * select a dataRow (it will add the attribute isSelected to the row object)\n     * @param {Object} row - the row to select\n     * @param {String} [mode] - \"single\" or \"multiple\" (multiple by default)\n     */\n    this.select = function select (row, mode) {\n      var rows = safeCopy;\n      var index = rows.indexOf(row);\n      if (index !== -1) {\n        if (mode === 'single') {\n          row.isSelected = row.isSelected !== true;\n          if (lastSelected) {\n            lastSelected.isSelected = false;\n          }\n          lastSelected = row.isSelected === true ? row : undefined;\n        } else {\n          rows[index].isSelected = !rows[index].isSelected;\n        }\n      }\n    };\n\n    /**\n     * take a slice of the current sorted/filtered collection (pagination)\n     *\n     * @param {Number} start - start index of the slice\n     * @param {Number} number - the number of item in the slice\n     */\n    this.slice = function splice (start, number) {\n      tableState.pagination.start = start;\n      tableState.pagination.number = number;\n      return this.pipe();\n    };\n\n    /**\n     * return the current state of the table\n     * @returns {{sort: {}, search: {}, pagination: {start: number}}}\n     */\n    this.tableState = function getTableState () {\n      return tableState;\n    };\n\n    this.getFilteredCollection = function getFilteredCollection () {\n      return filtered || safeCopy;\n    };\n\n    /**\n     * Use a different filter function than the angular FilterFilter\n     * @param filterName the name under which the custom filter is registered\n     */\n    this.setFilterFunction = function setFilterFunction (filterName) {\n      filter = $filter(filterName);\n    };\n\n    /**\n     * Use a different function than the angular orderBy\n     * @param sortFunctionName the name under which the custom order function is registered\n     */\n    this.setSortFunction = function setSortFunction (sortFunctionName) {\n      orderBy = $filter(sortFunctionName);\n    };\n\n    /**\n     * Usually when the safe copy is updated the pipe function is called.\n     * Calling this method will prevent it, which is something required when using a custom pipe function\n     */\n    this.preventPipeOnWatch = function preventPipe () {\n      pipeAfterSafeCopy = false;\n    };\n  }])\n  .directive('stTable', function () {\n    return {\n      restrict: 'A',\n      controller: 'stTableController',\n      link: function (scope, element, attr, ctrl) {\n\n        if (attr.stSetFilter) {\n          ctrl.setFilterFunction(attr.stSetFilter);\n        }\n\n        if (attr.stSetSort) {\n          ctrl.setSortFunction(attr.stSetSort);\n        }\n      }\n    };\n  });\n","ng.module('smart-table')\n  .directive('stSearch', ['stConfig', '$timeout', function (stConfig, $timeout) {\n    return {\n      require: '^stTable',\n      scope: {\n        predicate: '=?stSearch'\n      },\n      link: function (scope, element, attr, ctrl) {\n        var tableCtrl = ctrl;\n        var promise = null;\n        var throttle = attr.stDelay || stConfig.search.delay;\n\n        scope.$watch('predicate', function (newValue, oldValue) {\n          if (newValue !== oldValue) {\n            ctrl.tableState().search = {};\n            tableCtrl.search(element[0].value || '', newValue);\n          }\n        });\n\n        //table state -> view\n        scope.$watch(function () {\n          return ctrl.tableState().search;\n        }, function (newValue, oldValue) {\n          var predicateExpression = scope.predicate || '$';\n          if (newValue.predicateObject && newValue.predicateObject[predicateExpression] !== element[0].value) {\n            element[0].value = newValue.predicateObject[predicateExpression] || '';\n          }\n        }, true);\n\n        // view -> table state\n        element.bind('input', function (evt) {\n          evt = evt.originalEvent || evt;\n          if (promise !== null) {\n            $timeout.cancel(promise);\n          }\n          promise = $timeout(function () {\n            tableCtrl.search(evt.target.value, scope.predicate || '');\n            promise = null;\n          }, throttle);\n        });\n      }\n    };\n  }]);\n","ng.module('smart-table')\n  .directive('stSelectRow', ['stConfig', function (stConfig) {\n    return {\n      restrict: 'A',\n      require: '^stTable',\n      scope: {\n        row: '=stSelectRow'\n      },\n      link: function (scope, element, attr, ctrl) {\n        var mode = attr.stSelectMode || stConfig.select.mode;\n        element.bind('click', function () {\n          scope.$apply(function () {\n            ctrl.select(scope.row, mode);\n          });\n        });\n\n        scope.$watch('row.isSelected', function (newValue) {\n          if (newValue === true) {\n            element.addClass(stConfig.select.selectedClass);\n          } else {\n            element.removeClass(stConfig.select.selectedClass);\n          }\n        });\n      }\n    };\n  }]);\n","ng.module('smart-table')\n  .directive('stSort', ['stConfig', '$parse', function (stConfig, $parse) {\n    return {\n      restrict: 'A',\n      require: '^stTable',\n      link: function (scope, element, attr, ctrl) {\n\n        var predicate = attr.stSort;\n        var getter = $parse(predicate);\n        var index = 0;\n        var classAscent = attr.stClassAscent || stConfig.sort.ascentClass;\n        var classDescent = attr.stClassDescent || stConfig.sort.descentClass;\n        var stateClasses = [classAscent, classDescent];\n        var sortDefault;\n\n        if (attr.stSortDefault) {\n          sortDefault = scope.$eval(attr.stSortDefault) !== undefined ? scope.$eval(attr.stSortDefault) : attr.stSortDefault;\n        }\n\n        //view --> table state\n        function sort () {\n          index++;\n          predicate = ng.isFunction(getter(scope)) ? getter(scope) : attr.stSort;\n          if (index % 3 === 0 && attr.stSkipNatural === undefined) {\n            //manual reset\n            index = 0;\n            ctrl.tableState().sort = {};\n            ctrl.tableState().pagination.start = 0;\n            ctrl.pipe();\n          } else {\n            ctrl.sortBy(predicate, index % 2 === 0);\n          }\n        }\n\n        element.bind('click', function sortClick () {\n          if (predicate) {\n            scope.$apply(sort);\n          }\n        });\n\n        if (sortDefault) {\n          index = sortDefault === 'reverse' ? 1 : 0;\n          sort();\n        }\n\n        //table state --> view\n        scope.$watch(function () {\n          return ctrl.tableState().sort;\n        }, function (newValue) {\n          if (newValue.predicate !== predicate) {\n            index = 0;\n            element\n              .removeClass(classAscent)\n              .removeClass(classDescent);\n          } else {\n            index = newValue.reverse === true ? 2 : 1;\n            element\n              .removeClass(stateClasses[index % 2])\n              .addClass(stateClasses[index - 1]);\n          }\n        }, true);\n      }\n    };\n  }]);\n","ng.module('smart-table')\n  .directive('stPagination', ['stConfig', function (stConfig) {\n    return {\n      restrict: 'EA',\n      require: '^stTable',\n      scope: {\n        stItemsByPage: '=?',\n        stDisplayedPages: '=?',\n        stPageChange: '&'\n      },\n      templateUrl: function (element, attrs) {\n        if (attrs.stTemplate) {\n          return attrs.stTemplate;\n        }\n        return stConfig.pagination.template;\n      },\n      link: function (scope, element, attrs, ctrl) {\n\n        scope.stItemsByPage = scope.stItemsByPage ? +(scope.stItemsByPage) : stConfig.pagination.itemsByPage;\n        scope.stDisplayedPages = scope.stDisplayedPages ? +(scope.stDisplayedPages) : stConfig.pagination.displayedPages;\n\n        scope.currentPage = 1;\n        scope.pages = [];\n\n        function redraw () {\n          var paginationState = ctrl.tableState().pagination;\n          var start = 1;\n          var end;\n          var i;\n          var prevPage = scope.currentPage;\n          scope.currentPage = Math.floor(paginationState.start / paginationState.number) + 1;\n\n          start = Math.max(start, scope.currentPage - Math.abs(Math.floor(scope.stDisplayedPages / 2)));\n          end = start + scope.stDisplayedPages;\n\n          if (end > paginationState.numberOfPages) {\n            end = paginationState.numberOfPages + 1;\n            start = Math.max(1, end - scope.stDisplayedPages);\n          }\n\n          scope.pages = [];\n          scope.numPages = paginationState.numberOfPages;\n\n          for (i = start; i < end; i++) {\n            scope.pages.push(i);\n          }\n\n          if (prevPage !== scope.currentPage) {\n            scope.stPageChange({newPage: scope.currentPage});\n          }\n        }\n\n        //table state --> view\n        scope.$watch(function () {\n          return ctrl.tableState().pagination;\n        }, redraw, true);\n\n        //scope --> table state  (--> view)\n        scope.$watch('stItemsByPage', function (newValue, oldValue) {\n          if (newValue !== oldValue) {\n            scope.selectPage(1);\n          }\n        });\n\n        scope.$watch('stDisplayedPages', redraw);\n\n        //view -> table state\n        scope.selectPage = function (page) {\n          if (page > 0 && page <= scope.numPages) {\n            ctrl.slice((page - 1) * scope.stItemsByPage, scope.stItemsByPage);\n          }\n        };\n\n        if (!ctrl.tableState().pagination.number) {\n          ctrl.slice(0, scope.stItemsByPage);\n        }\n      }\n    };\n  }]);\n","ng.module('smart-table')\n  .directive('stPipe', function () {\n    return {\n      require: 'stTable',\n      scope: {\n        stPipe: '='\n      },\n      link: {\n\n        pre: function (scope, element, attrs, ctrl) {\n          if (ng.isFunction(scope.stPipe)) {\n            ctrl.preventPipeOnWatch();\n            ctrl.pipe = function () {\n              return scope.stPipe(ctrl.tableState(), ctrl);\n            }\n          }\n        },\n\n        post: function (scope, element, attrs, ctrl) {\n          ctrl.pipe();\n        }\n      }\n    };\n  });\n","})(angular);"],"sourceRoot":"/source/"}
\ No newline at end of file |