N°7063 - Forms SDK - Add Symfony forms component

error forms issue

node_modules/@orchidjs/sifter/dist/esm/lib/sifter.js

@@ -0,0 +1,368 @@
+/*! sifter.js | https://github.com/orchidjs/sifter.js | Apache License (v2) */
+import { iterate, cmp, propToArray, getAttrNesting, getAttr, scoreValue } from './utils.js';
+export { cmp, getAttr, getAttrNesting, iterate, propToArray, scoreValue } from './utils.js';
+import { getPattern } from '../node_modules/@orchidjs/unicode-variants/dist/esm/index.js';
+export { getPattern } from '../node_modules/@orchidjs/unicode-variants/dist/esm/index.js';
+import { escape_regex } from '../node_modules/@orchidjs/unicode-variants/dist/esm/regex.js';
+
+/**
+ * sifter.js
+ * Copyright (c) 2013–2020 Brian Reavis & contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+ * ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ *
+ * @author Brian Reavis <brian@thirdroute.com>
+ */
+
+class Sifter {
+  // []|{};
+
+  /**
+   * Textually searches arrays and hashes of objects
+   * by property (or multiple properties). Designed
+   * specifically for autocomplete.
+   *
+   */
+  constructor(items, settings) {
+    this.items = void 0;
+    this.settings = void 0;
+    this.items = items;
+    this.settings = settings || {
+      diacritics: true
+    };
+  }
+
+  /**
+   * Splits a search string into an array of individual
+   * regexps to be used to match results.
+   *
+   */
+  tokenize(query, respect_word_boundaries, weights) {
+    if (!query || !query.length) return [];
+    const tokens = [];
+    const words = query.split(/\s+/);
+    var field_regex;
+
+    if (weights) {
+      field_regex = new RegExp('^(' + Object.keys(weights).map(escape_regex).join('|') + ')\:(.*)$');
+    }
+
+    words.forEach(word => {
+      let field_match;
+      let field = null;
+      let regex = null; // look for "field:query" tokens
+
+      if (field_regex && (field_match = word.match(field_regex))) {
+        field = field_match[1];
+        word = field_match[2];
+      }
+
+      if (word.length > 0) {
+        if (this.settings.diacritics) {
+          regex = getPattern(word) || null;
+        } else {
+          regex = escape_regex(word);
+        }
+
+        if (regex && respect_word_boundaries) regex = "\\b" + regex;
+      }
+
+      tokens.push({
+        string: word,
+        regex: regex ? new RegExp(regex, 'iu') : null,
+        field: field
+      });
+    });
+    return tokens;
+  }
+
+  /**
+   * Returns a function to be used to score individual results.
+   *
+   * Good matches will have a higher score than poor matches.
+   * If an item is not a match, 0 will be returned by the function.
+   *
+   * @returns {T.ScoreFn}
+   */
+  getScoreFunction(query, options) {
+    var search = this.prepareSearch(query, options);
+    return this._getScoreFunction(search);
+  }
+  /**
+   * @returns {T.ScoreFn}
+   *
+   */
+
+
+  _getScoreFunction(search) {
+    const tokens = search.tokens,
+          token_count = tokens.length;
+
+    if (!token_count) {
+      return function () {
+        return 0;
+      };
+    }
+
+    const fields = search.options.fields,
+          weights = search.weights,
+          field_count = fields.length,
+          getAttrFn = search.getAttrFn;
+
+    if (!field_count) {
+      return function () {
+        return 1;
+      };
+    }
+    /**
+     * Calculates the score of an object
+     * against the search query.
+     *
+     */
+
+
+    const scoreObject = function () {
+      if (field_count === 1) {
+        return function (token, data) {
+          const field = fields[0].field;
+          return scoreValue(getAttrFn(data, field), token, weights[field] || 1);
+        };
+      }
+
+      return function (token, data) {
+        var sum = 0; // is the token specific to a field?
+
+        if (token.field) {
+          const value = getAttrFn(data, token.field);
+
+          if (!token.regex && value) {
+            sum += 1 / field_count;
+          } else {
+            sum += scoreValue(value, token, 1);
+          }
+        } else {
+          iterate(weights, (weight, field) => {
+            sum += scoreValue(getAttrFn(data, field), token, weight);
+          });
+        }
+
+        return sum / field_count;
+      };
+    }();
+
+    if (token_count === 1) {
+      return function (data) {
+        return scoreObject(tokens[0], data);
+      };
+    }
+
+    if (search.options.conjunction === 'and') {
+      return function (data) {
+        var score,
+            sum = 0;
+
+        for (let token of tokens) {
+          score = scoreObject(token, data);
+          if (score <= 0) return 0;
+          sum += score;
+        }
+
+        return sum / token_count;
+      };
+    } else {
+      return function (data) {
+        var sum = 0;
+        iterate(tokens, token => {
+          sum += scoreObject(token, data);
+        });
+        return sum / token_count;
+      };
+    }
+  }
+
+  /**
+   * Returns a function that can be used to compare two
+   * results, for sorting purposes. If no sorting should
+   * be performed, `null` will be returned.
+   *
+   * @return function(a,b)
+   */
+  getSortFunction(query, options) {
+    var search = this.prepareSearch(query, options);
+    return this._getSortFunction(search);
+  }
+
+  _getSortFunction(search) {
+    var implicit_score,
+        sort_flds = [];
+    const self = this,
+          options = search.options,
+          sort = !search.query && options.sort_empty ? options.sort_empty : options.sort;
+
+    if (typeof sort == 'function') {
+      return sort.bind(this);
+    }
+    /**
+     * Fetches the specified sort field value
+     * from a search result item.
+     *
+     */
+
+
+    const get_field = function get_field(name, result) {
+      if (name === '$score') return result.score;
+      return search.getAttrFn(self.items[result.id], name);
+    }; // parse options
+
+
+    if (sort) {
+      for (let s of sort) {
+        if (search.query || s.field !== '$score') {
+          sort_flds.push(s);
+        }
+      }
+    } // the "$score" field is implied to be the primary
+    // sort field, unless it's manually specified
+
+
+    if (search.query) {
+      implicit_score = true;
+
+      for (let fld of sort_flds) {
+        if (fld.field === '$score') {
+          implicit_score = false;
+          break;
+        }
+      }
+
+      if (implicit_score) {
+        sort_flds.unshift({
+          field: '$score',
+          direction: 'desc'
+        });
+      } // without a search.query, all items will have the same score
+
+    } else {
+      sort_flds = sort_flds.filter(fld => fld.field !== '$score');
+    } // build function
+
+
+    const sort_flds_count = sort_flds.length;
+
+    if (!sort_flds_count) {
+      return null;
+    }
+
+    return function (a, b) {
+      var result, field;
+
+      for (let sort_fld of sort_flds) {
+        field = sort_fld.field;
+        let multiplier = sort_fld.direction === 'desc' ? -1 : 1;
+        result = multiplier * cmp(get_field(field, a), get_field(field, b));
+        if (result) return result;
+      }
+
+      return 0;
+    };
+  }
+
+  /**
+   * Parses a search query and returns an object
+   * with tokens and fields ready to be populated
+   * with results.
+   *
+   */
+  prepareSearch(query, optsUser) {
+    const weights = {};
+    var options = Object.assign({}, optsUser);
+    propToArray(options, 'sort');
+    propToArray(options, 'sort_empty'); // convert fields to new format
+
+    if (options.fields) {
+      propToArray(options, 'fields');
+      const fields = [];
+      options.fields.forEach(field => {
+        if (typeof field == 'string') {
+          field = {
+            field: field,
+            weight: 1
+          };
+        }
+
+        fields.push(field);
+        weights[field.field] = 'weight' in field ? field.weight : 1;
+      });
+      options.fields = fields;
+    }
+
+    return {
+      options: options,
+      query: query.toLowerCase().trim(),
+      tokens: this.tokenize(query, options.respect_word_boundaries, weights),
+      total: 0,
+      items: [],
+      weights: weights,
+      getAttrFn: options.nesting ? getAttrNesting : getAttr
+    };
+  }
+
+  /**
+   * Searches through all items and returns a sorted array of matches.
+   *
+   */
+  search(query, options) {
+    var self = this,
+        score,
+        search;
+    search = this.prepareSearch(query, options);
+    options = search.options;
+    query = search.query; // generate result scoring function
+
+    const fn_score = options.score || self._getScoreFunction(search); // perform search and sort
+
+
+    if (query.length) {
+      iterate(self.items, (item, id) => {
+        score = fn_score(item);
+
+        if (options.filter === false || score > 0) {
+          search.items.push({
+            'score': score,
+            'id': id
+          });
+        }
+      });
+    } else {
+      iterate(self.items, (_, id) => {
+        search.items.push({
+          'score': 1,
+          'id': id
+        });
+      });
+    }
+
+    const fn_sort = self._getSortFunction(search);
+
+    if (fn_sort) search.items.sort(fn_sort); // apply limits
+
+    search.total = search.items.length;
+
+    if (typeof options.limit === 'number') {
+      search.items = search.items.slice(0, options.limit);
+    }
+
+    return search;
+  }
+
+}
+
+export { Sifter };
+//# sourceMappingURL=sifter.js.map

node_modules/@orchidjs/sifter/dist/esm/lib/utils.js

@@ -0,0 +1,95 @@
+/*! sifter.js | https://github.com/orchidjs/sifter.js | Apache License (v2) */
+import { asciifold } from '../node_modules/@orchidjs/unicode-variants/dist/esm/index.js';
+
+/**
+ * A property getter resolving dot-notation
+ * @param  {Object}  obj     The root object to fetch property on
+ * @param  {String}  name    The optionally dotted property name to fetch
+ * @return {Object}          The resolved property value
+ */
+const getAttr = (obj, name) => {
+  if (!obj) return;
+  return obj[name];
+};
+/**
+ * A property getter resolving dot-notation
+ * @param  {Object}  obj     The root object to fetch property on
+ * @param  {String}  name    The optionally dotted property name to fetch
+ * @return {Object}          The resolved property value
+ */
+
+const getAttrNesting = (obj, name) => {
+  if (!obj) return;
+  var part,
+      names = name.split(".");
+
+  while ((part = names.shift()) && (obj = obj[part]));
+
+  return obj;
+};
+/**
+ * Calculates how close of a match the
+ * given value is against a search token.
+ *
+ */
+
+const scoreValue = (value, token, weight) => {
+  var score, pos;
+  if (!value) return 0;
+  value = value + '';
+  if (token.regex == null) return 0;
+  pos = value.search(token.regex);
+  if (pos === -1) return 0;
+  score = token.string.length / value.length;
+  if (pos === 0) score += 0.5;
+  return score * weight;
+};
+/**
+ * Cast object property to an array if it exists and has a value
+ *
+ */
+
+const propToArray = (obj, key) => {
+  var value = obj[key];
+  if (typeof value == 'function') return value;
+
+  if (value && !Array.isArray(value)) {
+    obj[key] = [value];
+  }
+};
+/**
+ * Iterates over arrays and hashes.
+ *
+ * ```
+ * iterate(this.items, function(item, id) {
+ *    // invoked for each item
+ * });
+ * ```
+ *
+ */
+
+const iterate = (object, callback) => {
+  if (Array.isArray(object)) {
+    object.forEach(callback);
+  } else {
+    for (var key in object) {
+      if (object.hasOwnProperty(key)) {
+        callback(object[key], key);
+      }
+    }
+  }
+};
+const cmp = (a, b) => {
+  if (typeof a === 'number' && typeof b === 'number') {
+    return a > b ? 1 : a < b ? -1 : 0;
+  }
+
+  a = asciifold(a + '').toLowerCase();
+  b = asciifold(b + '').toLowerCase();
+  if (a > b) return 1;
+  if (b > a) return -1;
+  return 0;
+};
+
+export { cmp, getAttr, getAttrNesting, iterate, propToArray, scoreValue };
+//# sourceMappingURL=utils.js.map

node_modules/@orchidjs/sifter/dist/esm/lib/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sources":["../../../lib/utils.ts"],"sourcesContent":["\nimport { asciifold } from '@orchidjs/unicode-variants';\nimport * as T from './types';\n\n\n/**\n * A property getter resolving dot-notation\n * @param  {Object}  obj     The root object to fetch property on\n * @param  {String}  name    The optionally dotted property name to fetch\n * @return {Object}          The resolved property value\n */\nexport const getAttr = (obj:{[key:string]:any}, name:string ) => {\n    if (!obj ) return;\n    return obj[name];\n};\n\n/**\n * A property getter resolving dot-notation\n * @param  {Object}  obj     The root object to fetch property on\n * @param  {String}  name    The optionally dotted property name to fetch\n * @return {Object}          The resolved property value\n */\nexport const getAttrNesting = (obj:{[key:string]:any}, name:string ) => {\n    if (!obj ) return;\n    var part, names = name.split(\".\");\n\twhile( (part = names.shift()) && (obj = obj[part]));\n    return obj;\n};\n\n/**\n * Calculates how close of a match the\n * given value is against a search token.\n *\n */\nexport const scoreValue = (value:string, token:T.Token, weight:number ):number => {\n\tvar score, pos;\n\n\tif (!value) return 0;\n\n\tvalue = value + '';\n\tif( token.regex == null ) return 0;\n\tpos = value.search(token.regex);\n\tif (pos === -1) return 0;\n\n\tscore = token.string.length / value.length;\n\tif (pos === 0) score += 0.5;\n\n\treturn score * weight;\n};\n\n\n/**\n * Cast object property to an array if it exists and has a value\n *\n */\nexport const propToArray = (obj:{[key:string]:any}, key:string) => {\n\tvar value = obj[key];\n\n\tif( typeof value == 'function' ) return value;\n\n\tif( value && !Array.isArray(value) ){\n\t\tobj[key] = [value];\n\t}\n}\n\n\n/**\n * Iterates over arrays and hashes.\n *\n * ```\n * iterate(this.items, function(item, id) {\n *    // invoked for each item\n * });\n * ```\n *\n */\nexport const iterate = (object:[]|{[key:string]:any}, callback:(value:any,key:any)=>any) => {\n\n\tif ( Array.isArray(object)) {\n\t\tobject.forEach(callback);\n\n\t}else{\n\n\t\tfor (var key in object) {\n\t\t\tif (object.hasOwnProperty(key)) {\n\t\t\t\tcallback(object[key], key);\n\t\t\t}\n\t\t}\n\t}\n};\n\n\n\nexport const cmp = (a:number|string, b:number|string) => {\n\tif (typeof a === 'number' && typeof b === 'number') {\n\t\treturn a > b ? 1 : (a < b ? -1 : 0);\n\t}\n\ta = asciifold(a + '').toLowerCase();\n\tb = asciifold(b + '').toLowerCase();\n\tif (a > b) return 1;\n\tif (b > a) return -1;\n\treturn 0;\n};\n"],"names":["getAttr","obj","name","getAttrNesting","part","names","split","shift","scoreValue","value","token","weight","score","pos","regex","search","string","length","propToArray","key","Array","isArray","iterate","object","callback","forEach","hasOwnProperty","cmp","a","b","asciifold","toLowerCase"],"mappings":"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"}