dergeorg/SmartShopper
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

done purchases remove, ocr scan, read image

Browse Source
This commit is contained in:
LukasNowy
2019-01-28 01:34:06 +01:00
parent d9c3d422d7
commit 93bbf9c2cb
203 changed files with 21267 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
express-server/node_modules/string-similarity/LICENSE generated vendored Normal file
View File

@@ -0,0 +1,21 @@
MIT License
Copyright (c) 2018 Akash Kurdekar
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.

124
express-server/node_modules/string-similarity/README.md generated vendored Normal file
View File

@@ -0,0 +1,124 @@
string-similarity
=================
Finds degree of similarity between two strings, based on [Dice's Coefficient](http://en.wikipedia.org/wiki/S%C3%B8rensen%E2%80%93Dice_coefficient), which is mostly better than [Levenshtein distance](http://en.wikipedia.org/wiki/Levenshtein_distance).
## Table of Contents
* [Usage](#usage)
* [API](#api)
* [compareTwoStrings(string1, string2)](#comparetwostringsstring1-string2)
* [Arguments](#arguments)
* [Returns](#returns)
* [Examples](#examples)
* [findBestMatch(mainString, targetStrings)](#findbestmatchmainstring-targetstrings)
* [Arguments](#arguments-1)
* [Returns](#returns-1)
* [Examples](#examples-1)
* [Release Notes](#release-notes)
* [2.0.0](#200)
* [3.0.0](#300)
## Usage
Install using:
```shell
npm install string-similarity --save
```
In your code:
```javascript
var stringSimilarity = require('string-similarity');
var similarity = stringSimilarity.compareTwoStrings('healed', 'sealed');
var matches = stringSimilarity.findBestMatch('healed', ['edward', 'sealed', 'theatre']);
```
## API
Requiring the module gives an object with two methods:
### compareTwoStrings(string1, string2)
Returns a fraction between 0 and 1, which indicates the degree of similarity between the two strings. 0 indicates completely different strings, 1 indicates identical strings. The comparison is case-sensitive.
##### Arguments
1. string1 (string): The first string
2. string2 (string): The second string
Order does not make a difference.
##### Returns
(number): A fraction from 0 to 1, both inclusive. Higher number indicates more similarity.
##### Examples
```javascript
stringSimilarity.compareTwoStrings('healed', 'sealed');
// → 0.8
stringSimilarity.compareTwoStrings('Olive-green table for sale, in extremely good condition.',
'For sale: table in very good condition, olive green in colour.');
// → 0.6060606060606061
stringSimilarity.compareTwoStrings('Olive-green table for sale, in extremely good condition.',
'For sale: green Subaru Impreza, 210,000 miles');
// → 0.2558139534883721
stringSimilarity.compareTwoStrings('Olive-green table for sale, in extremely good condition.',
'Wanted: mountain bike with at least 21 gears.');
// → 0.1411764705882353
```
### findBestMatch(mainString, targetStrings)
Compares `mainString` against each string in `targetStrings`.
##### Arguments
1. mainString (string): The string to match each target string against.
2. targetStrings (Array): Each string in this array will be matched against the main string.
##### Returns
(Object): An object with a `ratings` property, which gives a similarity rating for each target string, a `bestMatch` property, which specifies which target string was most similar to the main string, and a `bestMatchIndex` property, which specifies the index of the bestMatch in the targetStrings array.
##### Examples
```javascript
stringSimilarity.findBestMatch('Olive-green table for sale, in extremely good condition.', [
'For sale: green Subaru Impreza, 210,000 miles',
'For sale: table in very good condition, olive green in colour.',
'Wanted: mountain bike with at least 21 gears.'
]);
// →
{ ratings:
[ { target: 'For sale: green Subaru Impreza, 210,000 miles',
rating: 0.2558139534883721 },
{ target: 'For sale: table in very good condition, olive green in colour.',
rating: 0.6060606060606061 },
{ target: 'Wanted: mountain bike with at least 21 gears.',
rating: 0.1411764705882353 } ],
bestMatch:
{ target: 'For sale: table in very good condition, olive green in colour.',
rating: 0.6060606060606061 },
bestMatchIndex: 1
}
```
## Release Notes
### 2.0.0
* Removed production dependencies
* Updated to ES6 (this breaks backward-compatibility for pre-ES6 apps)
### 3.0.0
* Performance improvement for `compareTwoStrings(..)`: now O(n) instead of O(n^2)
* The algorithm has been tweaked slightly to disregard spaces and word boundaries. This will change the rating values slightly but not enough to make a significant difference
* Adding a `bestMatchIndex` to the results for `findBestMatch(..)` to point to the best match in the supplied `targetStrings` array
![Build status](https://codeship.com/projects/2aa453d0-0959-0134-8a76-4abcb29fe9b4/status?branch=master)
[![Known Vulnerabilities](https://snyk.io/test/github/aceakash/string-similarity/badge.svg)](https://snyk.io/test/github/aceakash/string-similarity)

84
express-server/node_modules/string-similarity/compare-strings.js generated vendored Normal file
View File

@@ -0,0 +1,84 @@
module.exports = {
compareTwoStrings,
findBestMatch
};
function compareTwoStrings(first, second) {
first = first.replace(/\s+/g, '')
second = second.replace(/\s+/g, '')
if (!first.length && !second.length) return 1; // if both are empty strings
if (!first.length || !second.length) return 0; // if only one is empty string
if (first === second) return 1; // identical
if (first.length === 1 && second.length === 1) return 0; // both are 1-letter strings
if (first.length < 2 || second.length < 2) return 0; // if either is a 1-letter string
let firstBigrams = new Map();
for (let i = 0; i < first.length - 1; i++) {
const bigram = first.substr(i, 2);
const count = firstBigrams.has(bigram)
? firstBigrams.get(bigram) + 1
: 1;
firstBigrams.set(bigram, count);
};
let intersectionSize = 0;
for (let i = 0; i < second.length - 1; i++) {
const bigram = second.substr(i, 2);
const count = firstBigrams.has(bigram)
? firstBigrams.get(bigram)
: 0;
if (count > 0) {
firstBigrams.set(bigram, count - 1);
intersectionSize++;
}
}
return (2.0 * intersectionSize) / (first.length + second.length - 2);
}
function findBestMatch(mainString, targetStrings) {
if (!areArgsValid(mainString, targetStrings)) throw new Error('Bad arguments: First argument should be a string, second should be an array of strings');
const ratings = [];
let bestMatchIndex = 0;
for (let i = 0; i < targetStrings.length; i++) {
const currentTargetString = targetStrings[i];
const currentRating = compareTwoStrings(mainString, currentTargetString)
ratings.push({target: currentTargetString, rating: currentRating})
if (currentRating > ratings[bestMatchIndex].rating) {
bestMatchIndex = i
}
}
const bestMatch = ratings[bestMatchIndex]
return { ratings, bestMatch, bestMatchIndex };
}
function flattenDeep(arr) {
return Array.isArray(arr) ? arr.reduce((a, b) => a.concat(flattenDeep(b)), []) : [arr];
}
function areArgsValid(mainString, targetStrings) {
if (typeof mainString !== 'string') return false;
if (!Array.isArray(targetStrings)) return false;
if (!targetStrings.length) return false;
if (targetStrings.find(s => typeof s !== 'string')) return false;
return true;
}
function letterPairs(str) {
const pairs = [];
for (let i = 0, max = str.length - 1; i < max; i++) pairs[i] = str.substring(i, i + 2);
return pairs;
}
function wordLetterPairs(str) {
const pairs = str.toUpperCase().split(' ').map(letterPairs);
return flattenDeep(pairs);
}

68
express-server/node_modules/string-similarity/package.json generated vendored Normal file
View File

@@ -0,0 +1,68 @@
{
"_from": "string-similarity@^3.0.0",
"_id": "string-similarity@3.0.0",
"_inBundle": false,
"_integrity": "sha512-7kS7LyTp56OqOI2BDWQNVnLX/rCxIQn+/5M0op1WV6P8Xx6TZNdajpuqQdiJ7Xx+p1C5CsWMvdiBp9ApMhxzEQ==",
"_location": "/string-similarity",
"_phantomChildren": {},
"_requested": {
"type": "range",
"registry": true,
"raw": "string-similarity@^3.0.0",
"name": "string-similarity",
"escapedName": "string-similarity",
"rawSpec": "^3.0.0",
"saveSpec": null,
"fetchSpec": "^3.0.0"
},
"_requiredBy": [
"#USER",
"/"
],
"_resolved": "https://registry.npmjs.org/string-similarity/-/string-similarity-3.0.0.tgz",
"_shasum": "07b0bc69fae200ad88ceef4983878d03793847c7",
"_spec": "string-similarity@^3.0.0",
"_where": "D:\\5CHITM\\Diplomarbeit\\repos\\SmartShopper\\express-server",
"author": {
"name": "Akash Kurdekar",
"email": "npm@kurdekar.com",
"url": "http://untilfalse.com/"
},
"bugs": {
"url": "https://github.com/aceakash/string-similarity/issues"
},
"bundleDependencies": false,
"deprecated": false,
"description": "Finds degree of similarity between strings, based on Dice's Coefficient, which is mostly better than Levenshtein distance.",
"devDependencies": {
"jasmine": "^3.3.0"
},
"files": [
"compare-strings.js"
],
"homepage": "https://github.com/aceakash/string-similarity#readme",
"keywords": [
"strings",
"similar",
"difference",
"similarity",
"compare",
"comparison",
"degree",
"match",
"matching",
"dice",
"levenshtein"
],
"license": "ISC",
"main": "compare-strings.js",
"name": "string-similarity",
"repository": {
"type": "git",
"url": "git://github.com/aceakash/string-similarity.git"
},
"scripts": {
"test": "jasmine"
},
"version": "3.0.0"
}