files.com 1.0.418 → 1.0.420

package/README.md

@@ -157,6 +157,16 @@ You can set the following global properties using static methods on the `Files`
       const textContent = await downloadableFile.downloadToString()
     }
 
+#### Comparing Case insensitive files and paths
+
+For related documentation see [Case Sensitivity Documentation](https://www.files.com/docs/topics/file-system-semantics#case-sensitivity).
+
+    import { pathNormalizer } from 'files.com/lib/utils.js'
+
+    if (pathNormalizer.same('Fïłèńämê.Txt', 'filename.txt')) {
+      // the paths are the same
+    }
+
 ### Additional Object Documentation
 
 Additional docs are available at https://developers.files.com

package/_VERSION

@@ -1 +1 @@
-1.0.418
+1.0.420

package/lib/Files.js

@@ -11,7 +11,7 @@ var endpointPrefix = '/api/rest/v1';
 var apiKey;
 var baseUrl = 'https://app.files.com';
 var sessionId = null;
-var version = "1.0.418";
+var version = "1.0.420";
 var userAgent = "Files.com JavaScript SDK v".concat(version);
 var logLevel = _Logger.LogLevel.INFO;
 var debugRequest = false;

package/lib/utils/pathNormalizer.js

@@ -0,0 +1,262 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+// This implements the algorithm for path normalization described here:
+// https://www.files.com/docs/topics/file-system-semantics#exact-algorithm-for-path-normalization
+
+/* eslint-disable sort-keys */
+var transliterationMap = {
+  À: 'A',
+  Á: 'A',
+  Â: 'A',
+  Ã: 'A',
+  Ä: 'A',
+  Å: 'A',
+  Æ: 'AE',
+  Ç: 'C',
+  È: 'E',
+  É: 'E',
+  Ê: 'E',
+  Ë: 'E',
+  Ì: 'I',
+  Í: 'I',
+  Î: 'I',
+  Ï: 'I',
+  Ð: 'D',
+  Ñ: 'N',
+  Ò: 'O',
+  Ó: 'O',
+  Ô: 'O',
+  Õ: 'O',
+  Ö: 'O',
+  Ø: 'O',
+  Ù: 'U',
+  Ú: 'U',
+  Û: 'U',
+  Ü: 'U',
+  Ý: 'Y',
+  ß: 'ss',
+  à: 'a',
+  á: 'a',
+  â: 'a',
+  ã: 'a',
+  ä: 'a',
+  å: 'a',
+  æ: 'ae',
+  ç: 'c',
+  è: 'e',
+  é: 'e',
+  ê: 'e',
+  ë: 'e',
+  ì: 'i',
+  í: 'i',
+  î: 'i',
+  ï: 'i',
+  ð: 'd',
+  ñ: 'n',
+  ò: 'o',
+  ó: 'o',
+  ô: 'o',
+  õ: 'o',
+  ö: 'o',
+  ø: 'o',
+  ù: 'u',
+  ú: 'u',
+  û: 'u',
+  ü: 'u',
+  ý: 'y',
+  ÿ: 'y',
+  Ā: 'A',
+  ā: 'a',
+  Ă: 'A',
+  ă: 'a',
+  Ą: 'A',
+  ą: 'a',
+  Ć: 'C',
+  ć: 'c',
+  Ĉ: 'C',
+  ĉ: 'c',
+  Ċ: 'C',
+  ċ: 'c',
+  Č: 'C',
+  č: 'c',
+  Ď: 'D',
+  ď: 'd',
+  Đ: 'D',
+  đ: 'd',
+  Ē: 'E',
+  ē: 'e',
+  Ĕ: 'E',
+  ĕ: 'e',
+  Ė: 'E',
+  ė: 'e',
+  Ę: 'E',
+  ę: 'e',
+  Ě: 'E',
+  ě: 'e',
+  Ĝ: 'G',
+  ĝ: 'g',
+  Ğ: 'G',
+  ğ: 'g',
+  Ġ: 'G',
+  ġ: 'g',
+  Ģ: 'G',
+  ģ: 'g',
+  Ĥ: 'H',
+  ĥ: 'h',
+  Ħ: 'H',
+  ħ: 'h',
+  Ĩ: 'I',
+  ĩ: 'i',
+  Ī: 'I',
+  ī: 'i',
+  Ĭ: 'I',
+  ĭ: 'i',
+  Į: 'I',
+  į: 'i',
+  İ: 'I',
+  IJ: 'IJ',
+  ij: 'ij',
+  Ĵ: 'J',
+  ĵ: 'j',
+  Ķ: 'K',
+  ķ: 'k',
+  Ĺ: 'L',
+  ĺ: 'l',
+  Ļ: 'L',
+  ļ: 'l',
+  Ľ: 'L',
+  ľ: 'l',
+  Ł: 'L',
+  ł: 'l',
+  Ń: 'N',
+  ń: 'n',
+  Ņ: 'N',
+  ņ: 'n',
+  Ň: 'N',
+  ň: 'n',
+  ʼn: '\'n',
+  Ō: 'O',
+  ō: 'o',
+  Ŏ: 'O',
+  ŏ: 'o',
+  Ő: 'O',
+  ő: 'o',
+  Œ: 'OE',
+  œ: 'oe',
+  Ŕ: 'R',
+  ŕ: 'r',
+  Ŗ: 'R',
+  ŗ: 'r',
+  Ř: 'R',
+  ř: 'r',
+  Ś: 'S',
+  ś: 's',
+  Ŝ: 'S',
+  ŝ: 's',
+  Ş: 'S',
+  ş: 's',
+  Š: 'S',
+  š: 's',
+  Ţ: 'T',
+  ţ: 't',
+  Ť: 'T',
+  ť: 't',
+  Ũ: 'U',
+  ũ: 'u',
+  Ū: 'U',
+  ū: 'u',
+  Ŭ: 'U',
+  ŭ: 'u',
+  Ů: 'U',
+  ů: 'u',
+  Ű: 'U',
+  ű: 'u',
+  Ų: 'U',
+  ų: 'u',
+  Ŵ: 'W',
+  ŵ: 'w',
+  Ŷ: 'Y',
+  ŷ: 'y',
+  Ÿ: 'Y',
+  Ź: 'Z',
+  ź: 'z',
+  Ż: 'Z',
+  ż: 'z',
+  Ž: 'Z',
+  ž: 'z'
+};
+/* eslint-enable sort-keys */
+
+var transliterate = function transliterate(str) {
+  return Array.from(str).map(function (char) {
+    return transliterationMap[char] || char;
+  }).join('');
+};
+
+// converting the path to UTF-8 is not necessary in JS as it's the default
+var normalize = function normalize(path) {
+  // Remove any characters with byte value of 0
+  var cleaned = (typeof path === 'string' ? path : '').replace(/\0/g, '');
+
+  // Convert any backslash (\) characters to a forward slash (/)
+  cleaned = cleaned.replace(/\\/g, '/');
+
+  // Remove any trailing or leading slashes
+  cleaned = cleaned.replace(/^\/+|\/+$/g, '');
+
+  // Remove any path parts that are . or ..
+  cleaned = cleaned.split('/').filter(function (part) {
+    return part !== '.' && part !== '..';
+  }).join('/');
+
+  // Replace any duplicate forward slashes (such as ///) with a single forward slash (/)
+  cleaned = cleaned.replace(/\/+/g, '/');
+  return cleaned;
+};
+var normalizeForComparisonCache = new Map();
+var normalizeForComparison = function normalizeForComparison(path) {
+  if (normalizeForComparisonCache.has(path)) {
+    return normalizeForComparisonCache.get(path);
+  }
+
+  // Run the path through the Normalize Algorithm
+  var normalized = normalize(path);
+
+  // Unicode Normalize the Path using Unicode NFKC algorithm
+  normalized = normalized.normalize('NFKC');
+
+  // Transliterate and remove accent marks
+  normalized = transliterate(normalized);
+
+  // Convert the Path to lowercase
+  normalized = normalized.toLowerCase();
+
+  // Remove any trailing whitespace (\r, \n, \t or the space character)
+  normalized = normalized.replace(/[\r\n\t ]+$/g, '');
+  normalizeForComparisonCache.set(path, normalized);
+  return normalized;
+};
+var same = function same(path1, path2) {
+  return typeof path1 === 'string' && typeof path2 === 'string' && normalizeForComparison(path1) === normalizeForComparison(path2);
+};
+var startsWith = function startsWith(path1, path2) {
+  return typeof path1 === 'string' && typeof path2 === 'string' && normalizeForComparison(path1).startsWith(normalizeForComparison(path2));
+};
+var keyLookup = function keyLookup(object, path) {
+  var key = Object.keys(object || {}).find(function (key) {
+    return same(key, path);
+  });
+  return typeof key === 'string' ? object[key] : undefined;
+};
+var pathNormalizer = {
+  keyLookup: keyLookup,
+  normalize: normalize,
+  normalizeForComparison: normalizeForComparison,
+  same: same,
+  startsWith: startsWith
+};
+var _default = exports.default = pathNormalizer;
+module.exports = pathNormalizer;
+module.exports.default = pathNormalizer;

package/lib/utils/pathNormalizer.test.js

@@ -0,0 +1,88 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _pathNormalizer = _interopRequireDefault(require("./pathNormalizer"));
+var _normalization_for_comparison_test_data = _interopRequireDefault(require("../../../common/shared/normalization_for_comparison_test_data.json"));
+describe('pathNormalizer', function () {
+  it('normalizes paths for comparison', function () {
+    _normalization_for_comparison_test_data.default.forEach(function (_ref) {
+      var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
+        input = _ref2[0],
+        expected = _ref2[1];
+      expect(_pathNormalizer.default.same(input, expected)).toBe(true);
+      var startOfExpected = expected.substring(0, 3);
+      expect(_pathNormalizer.default.startsWith(input, startOfExpected)).toBe(true);
+    });
+  });
+  it('handles non-string params', function () {
+    expect(_pathNormalizer.default.normalize([])).toBe('');
+    expect(_pathNormalizer.default.normalize({})).toBe('');
+    expect(_pathNormalizer.default.normalize(null)).toBe('');
+    expect(_pathNormalizer.default.normalize(undefined)).toBe('');
+    expect(_pathNormalizer.default.same([], '')).toBe(false);
+    expect(_pathNormalizer.default.same(null, '')).toBe(false);
+    expect(_pathNormalizer.default.same([], null)).toBe(false);
+    expect(_pathNormalizer.default.same(undefined, undefined)).toBe(false);
+    expect(_pathNormalizer.default.startsWith(null, '')).toBe(false);
+    expect(_pathNormalizer.default.startsWith(null, [])).toBe(false);
+    expect(_pathNormalizer.default.startsWith([], null)).toBe(false);
+    expect(_pathNormalizer.default.startsWith(undefined, undefined)).toBe(false);
+    expect(_pathNormalizer.default.keyLookup(null, '')).toBe(undefined);
+    expect(_pathNormalizer.default.keyLookup(null, [])).toBe(undefined);
+    expect(_pathNormalizer.default.keyLookup([], null)).toBe(undefined);
+    expect(_pathNormalizer.default.keyLookup(undefined, undefined)).toBe(undefined);
+  });
+  it('looks up keys in a map', function () {
+    var map = {
+      '': {
+        list: true
+      },
+      foo: {
+        readonly: true
+      },
+      'foo/bar': {
+        read: false,
+        write: true
+      }
+    };
+    expect(_pathNormalizer.default.keyLookup(map, 'foo/bar')).toEqual({
+      read: false,
+      write: true
+    });
+    expect(_pathNormalizer.default.keyLookup(map, '/foo/bar')).toEqual({
+      read: false,
+      write: true
+    });
+    expect(_pathNormalizer.default.keyLookup(map, '.')).toEqual({
+      list: true
+    });
+    expect(_pathNormalizer.default.keyLookup(map, './..')).toEqual({
+      list: true
+    });
+    expect(_pathNormalizer.default.keyLookup(map, '')).toEqual({
+      list: true
+    });
+    expect(_pathNormalizer.default.keyLookup(map, '/')).toEqual({
+      list: true
+    });
+    expect(_pathNormalizer.default.keyLookup(map, '/ ')).toEqual({
+      list: true
+    });
+    expect(_pathNormalizer.default.keyLookup(map, '// ')).toEqual({
+      list: true
+    });
+    expect(_pathNormalizer.default.keyLookup(map, '////')).toEqual({
+      list: true
+    });
+    expect(_pathNormalizer.default.keyLookup(map, '/foo')).toEqual({
+      readonly: true
+    });
+    expect(_pathNormalizer.default.keyLookup(map, '/////foo')).toEqual({
+      readonly: true
+    });
+    expect(_pathNormalizer.default.keyLookup(map, '/////foo/')).toEqual({
+      readonly: true
+    });
+  });
+});

package/lib/utils.js

@@ -4,6 +4,8 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 exports.__esModule = true;
 exports.isString = exports.isObject = exports.isInt = exports.isEmpty = exports.isBrowser = exports.isArray = exports.getType = void 0;
 var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _pathNormalizer = _interopRequireDefault(require("./utils/pathNormalizer"));
+exports.pathNormalizer = _pathNormalizer.default;
 var isArray = exports.isArray = function isArray(value) {
   return Array.isArray(value);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "files.com",
-  "version": "1.0.418",
+  "version": "1.0.420",
   "description": "Files.com SDK for JavaScript",
   "keywords": [
     "files.com",
@@ -32,9 +32,12 @@
     "@babel/plugin-proposal-class-properties": "^7.10.1",
     "@babel/plugin-transform-modules-commonjs": "^7.10.1",
     "@babel/plugin-transform-runtime": "^7.10.3",
-    "@babel/preset-env": "^7.10.3"
+    "@babel/preset-env": "^7.10.3",
+    "jest": "^29.7.0"
   },
   "scripts": {
-    "build": "./node_modules/.bin/babel src -d lib"
+    "build": "./node_modules/.bin/babel src -d lib",
+    "test": "jest",
+    "watch": "jest --watch"
   }
 }

package/src/Files.js

@@ -5,7 +5,7 @@ const endpointPrefix = '/api/rest/v1'
 let apiKey
 let baseUrl = 'https://app.files.com'
 let sessionId = null
-let version = "1.0.418"
+let version = "1.0.420"
 let userAgent = `Files.com JavaScript SDK v${version}`
 
 let logLevel = LogLevel.INFO

package/src/utils/pathNormalizer.js

@@ -0,0 +1,262 @@
+// This implements the algorithm for path normalization described here:
+// https://www.files.com/docs/topics/file-system-semantics#exact-algorithm-for-path-normalization
+
+/* eslint-disable sort-keys */
+const transliterationMap = {
+  À: 'A',
+  Á: 'A',
+  Â: 'A',
+  Ã: 'A',
+  Ä: 'A',
+  Å: 'A',
+  Æ: 'AE',
+  Ç: 'C',
+  È: 'E',
+  É: 'E',
+  Ê: 'E',
+  Ë: 'E',
+  Ì: 'I',
+  Í: 'I',
+  Î: 'I',
+  Ï: 'I',
+  Ð: 'D',
+  Ñ: 'N',
+  Ò: 'O',
+  Ó: 'O',
+  Ô: 'O',
+  Õ: 'O',
+  Ö: 'O',
+  Ø: 'O',
+  Ù: 'U',
+  Ú: 'U',
+  Û: 'U',
+  Ü: 'U',
+  Ý: 'Y',
+  ß: 'ss',
+  à: 'a',
+  á: 'a',
+  â: 'a',
+  ã: 'a',
+  ä: 'a',
+  å: 'a',
+  æ: 'ae',
+  ç: 'c',
+  è: 'e',
+  é: 'e',
+  ê: 'e',
+  ë: 'e',
+  ì: 'i',
+  í: 'i',
+  î: 'i',
+  ï: 'i',
+  ð: 'd',
+  ñ: 'n',
+  ò: 'o',
+  ó: 'o',
+  ô: 'o',
+  õ: 'o',
+  ö: 'o',
+  ø: 'o',
+  ù: 'u',
+  ú: 'u',
+  û: 'u',
+  ü: 'u',
+  ý: 'y',
+  ÿ: 'y',
+  Ā: 'A',
+  ā: 'a',
+  Ă: 'A',
+  ă: 'a',
+  Ą: 'A',
+  ą: 'a',
+  Ć: 'C',
+  ć: 'c',
+  Ĉ: 'C',
+  ĉ: 'c',
+  Ċ: 'C',
+  ċ: 'c',
+  Č: 'C',
+  č: 'c',
+  Ď: 'D',
+  ď: 'd',
+  Đ: 'D',
+  đ: 'd',
+  Ē: 'E',
+  ē: 'e',
+  Ĕ: 'E',
+  ĕ: 'e',
+  Ė: 'E',
+  ė: 'e',
+  Ę: 'E',
+  ę: 'e',
+  Ě: 'E',
+  ě: 'e',
+  Ĝ: 'G',
+  ĝ: 'g',
+  Ğ: 'G',
+  ğ: 'g',
+  Ġ: 'G',
+  ġ: 'g',
+  Ģ: 'G',
+  ģ: 'g',
+  Ĥ: 'H',
+  ĥ: 'h',
+  Ħ: 'H',
+  ħ: 'h',
+  Ĩ: 'I',
+  ĩ: 'i',
+  Ī: 'I',
+  ī: 'i',
+  Ĭ: 'I',
+  ĭ: 'i',
+  Į: 'I',
+  į: 'i',
+  İ: 'I',
+  IJ: 'IJ',
+  ij: 'ij',
+  Ĵ: 'J',
+  ĵ: 'j',
+  Ķ: 'K',
+  ķ: 'k',
+  Ĺ: 'L',
+  ĺ: 'l',
+  Ļ: 'L',
+  ļ: 'l',
+  Ľ: 'L',
+  ľ: 'l',
+  Ł: 'L',
+  ł: 'l',
+  Ń: 'N',
+  ń: 'n',
+  Ņ: 'N',
+  ņ: 'n',
+  Ň: 'N',
+  ň: 'n',
+  ʼn: '\'n',
+  Ō: 'O',
+  ō: 'o',
+  Ŏ: 'O',
+  ŏ: 'o',
+  Ő: 'O',
+  ő: 'o',
+  Œ: 'OE',
+  œ: 'oe',
+  Ŕ: 'R',
+  ŕ: 'r',
+  Ŗ: 'R',
+  ŗ: 'r',
+  Ř: 'R',
+  ř: 'r',
+  Ś: 'S',
+  ś: 's',
+  Ŝ: 'S',
+  ŝ: 's',
+  Ş: 'S',
+  ş: 's',
+  Š: 'S',
+  š: 's',
+  Ţ: 'T',
+  ţ: 't',
+  Ť: 'T',
+  ť: 't',
+  Ũ: 'U',
+  ũ: 'u',
+  Ū: 'U',
+  ū: 'u',
+  Ŭ: 'U',
+  ŭ: 'u',
+  Ů: 'U',
+  ů: 'u',
+  Ű: 'U',
+  ű: 'u',
+  Ų: 'U',
+  ų: 'u',
+  Ŵ: 'W',
+  ŵ: 'w',
+  Ŷ: 'Y',
+  ŷ: 'y',
+  Ÿ: 'Y',
+  Ź: 'Z',
+  ź: 'z',
+  Ż: 'Z',
+  ż: 'z',
+  Ž: 'Z',
+  ž: 'z',
+}
+/* eslint-enable sort-keys */
+
+const transliterate = str =>
+  Array.from(str)
+    .map(char => transliterationMap[char] || char)
+    .join('')
+
+// converting the path to UTF-8 is not necessary in JS as it's the default
+const normalize = path => {
+  // Remove any characters with byte value of 0
+  let cleaned = (typeof path === 'string' ? path : '').replace(/\0/g, '')
+
+  // Convert any backslash (\) characters to a forward slash (/)
+  cleaned = cleaned.replace(/\\/g, '/')
+
+  // Remove any trailing or leading slashes
+  cleaned = cleaned.replace(/^\/+|\/+$/g, '')
+
+  // Remove any path parts that are . or ..
+  cleaned = cleaned.split('/').filter(part => part !== '.' && part !== '..').join('/')
+
+  // Replace any duplicate forward slashes (such as ///) with a single forward slash (/)
+  cleaned = cleaned.replace(/\/+/g, '/')
+
+  return cleaned
+}
+
+const normalizeForComparisonCache = new Map()
+
+const normalizeForComparison = path => {
+  if (normalizeForComparisonCache.has(path)) {
+    return normalizeForComparisonCache.get(path)
+  }
+
+  // Run the path through the Normalize Algorithm
+  let normalized = normalize(path)
+
+  // Unicode Normalize the Path using Unicode NFKC algorithm
+  normalized = normalized.normalize('NFKC')
+
+  // Transliterate and remove accent marks
+  normalized = transliterate(normalized)
+
+  // Convert the Path to lowercase
+  normalized = normalized.toLowerCase()
+
+  // Remove any trailing whitespace (\r, \n, \t or the space character)
+  normalized = normalized.replace(/[\r\n\t ]+$/g, '')
+
+  normalizeForComparisonCache.set(path, normalized)
+
+  return normalized
+}
+
+const same = (path1, path2) => typeof path1 === 'string' && typeof path2 === 'string'
+  && normalizeForComparison(path1) === normalizeForComparison(path2)
+
+const startsWith = (path1, path2) => typeof path1 === 'string' && typeof path2 === 'string'
+  && normalizeForComparison(path1).startsWith(normalizeForComparison(path2))
+
+const keyLookup = (object, path) => {
+  const key = Object.keys(object || {}).find(key => same(key, path))
+  return typeof key === 'string' ? object[key] : undefined
+}
+
+const pathNormalizer = {
+  keyLookup,
+  normalize,
+  normalizeForComparison,
+  same,
+  startsWith,
+}
+
+export default pathNormalizer
+
+module.exports = pathNormalizer
+module.exports.default = pathNormalizer

package/src/utils/pathNormalizer.test.js

@@ -0,0 +1,57 @@
+import pathNormalizer from './pathNormalizer'
+
+import normalizationForComparisonTestData from '../../../common/shared/normalization_for_comparison_test_data.json'
+
+describe('pathNormalizer', () => {
+  it('normalizes paths for comparison', () => {
+    normalizationForComparisonTestData.forEach(([input, expected]) => {
+      expect(pathNormalizer.same(input, expected)).toBe(true)
+
+      const startOfExpected = expected.substring(0, 3)
+      expect(pathNormalizer.startsWith(input, startOfExpected)).toBe(true)
+    })
+  })
+
+  it('handles non-string params', () => {
+    expect(pathNormalizer.normalize([])).toBe('')
+    expect(pathNormalizer.normalize({})).toBe('')
+    expect(pathNormalizer.normalize(null)).toBe('')
+    expect(pathNormalizer.normalize(undefined)).toBe('')
+
+    expect(pathNormalizer.same([], '')).toBe(false)
+    expect(pathNormalizer.same(null, '')).toBe(false)
+    expect(pathNormalizer.same([], null)).toBe(false)
+    expect(pathNormalizer.same(undefined, undefined)).toBe(false)
+
+    expect(pathNormalizer.startsWith(null, '')).toBe(false)
+    expect(pathNormalizer.startsWith(null, [])).toBe(false)
+    expect(pathNormalizer.startsWith([], null)).toBe(false)
+    expect(pathNormalizer.startsWith(undefined, undefined)).toBe(false)
+
+    expect(pathNormalizer.keyLookup(null, '')).toBe(undefined)
+    expect(pathNormalizer.keyLookup(null, [])).toBe(undefined)
+    expect(pathNormalizer.keyLookup([], null)).toBe(undefined)
+    expect(pathNormalizer.keyLookup(undefined, undefined)).toBe(undefined)
+  })
+
+  it('looks up keys in a map', () => {
+    const map = {
+      '': { list: true },
+      foo: { readonly: true },
+      'foo/bar': { read: false, write: true },
+    }
+
+    expect(pathNormalizer.keyLookup(map, 'foo/bar')).toEqual({ read: false, write: true })
+    expect(pathNormalizer.keyLookup(map, '/foo/bar')).toEqual({ read: false, write: true })
+    expect(pathNormalizer.keyLookup(map, '.')).toEqual({ list: true })
+    expect(pathNormalizer.keyLookup(map, './..')).toEqual({ list: true })
+    expect(pathNormalizer.keyLookup(map, '')).toEqual({ list: true })
+    expect(pathNormalizer.keyLookup(map, '/')).toEqual({ list: true })
+    expect(pathNormalizer.keyLookup(map, '/ ')).toEqual({ list: true })
+    expect(pathNormalizer.keyLookup(map, '// ')).toEqual({ list: true })
+    expect(pathNormalizer.keyLookup(map, '////')).toEqual({ list: true })
+    expect(pathNormalizer.keyLookup(map, '/foo')).toEqual({ readonly: true })
+    expect(pathNormalizer.keyLookup(map, '/////foo')).toEqual({ readonly: true })
+    expect(pathNormalizer.keyLookup(map, '/////foo/')).toEqual({ readonly: true })
+  })
+})

package/src/utils.js

@@ -1,3 +1,5 @@
+import pathNormalizer from './utils/pathNormalizer'
+
 const isArray = value => Array.isArray(value)
 
 const isInt = value => typeof value === 'number'
@@ -25,4 +27,5 @@ export {
   isInt,
   isObject,
   isString,
+  pathNormalizer,
 }