-
-
Notifications
You must be signed in to change notification settings - Fork 81
/
index.js
127 lines (98 loc) · 3.39 KB
/
index.js
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
import escapeStringRegexp from 'escape-string-regexp';
import transliterate from '@sindresorhus/transliterate';
import builtinOverridableReplacements from './overridable-replacements.js';
const decamelize = string => {
return string
// Separate capitalized words.
.replace(/([A-Z]{2,})(\d+)/g, '$1 $2')
.replace(/([a-z\d]+)([A-Z]{2,})/g, '$1 $2')
.replace(/([a-z\d])([A-Z])/g, '$1 $2')
// `[a-rt-z]` matches all lowercase characters except `s`.
// This avoids matching plural acronyms like `APIs`.
.replace(/([A-Z]+)([A-Z][a-rt-z\d]+)/g, '$1 $2');
};
const removeMootSeparators = (string, separator) => {
const escapedSeparator = escapeStringRegexp(separator);
return string
.replace(new RegExp(`${escapedSeparator}{2,}`, 'g'), separator)
.replace(new RegExp(`^${escapedSeparator}|${escapedSeparator}$`, 'g'), '');
};
const buildPatternSlug = options => {
let negationSetPattern = 'a-z\\d';
negationSetPattern += options.lowercase ? '' : 'A-Z';
if (options.preserveCharacters.length > 0) {
for (const character of options.preserveCharacters) {
if (character === options.separator) {
throw new Error(`The separator character \`${options.separator}\` cannot be included in preserved characters: ${options.preserveCharacters}`);
}
negationSetPattern += escapeStringRegexp(character);
}
}
return new RegExp(`[^${negationSetPattern}]+`, 'g');
};
export default function slugify(string, options) {
if (typeof string !== 'string') {
throw new TypeError(`Expected a string, got \`${typeof string}\``);
}
options = {
separator: '-',
lowercase: true,
decamelize: true,
customReplacements: [],
preserveLeadingUnderscore: false,
preserveTrailingDash: false,
preserveCharacters: [],
...options
};
const shouldPrependUnderscore = options.preserveLeadingUnderscore && string.startsWith('_');
const shouldAppendDash = options.preserveTrailingDash && string.endsWith('-');
const customReplacements = new Map([
...builtinOverridableReplacements,
...options.customReplacements
]);
string = transliterate(string, {customReplacements});
if (options.decamelize) {
string = decamelize(string);
}
const patternSlug = buildPatternSlug(options);
if (options.lowercase) {
string = string.toLowerCase();
}
// Detect contractions/possessives by looking for any word followed by a `'t`
// or `'s` in isolation and then remove it.
string = string.replace(/([a-zA-Z\d]+)'([ts])(\s|$)/g, '$1$2$3');
string = string.replace(patternSlug, options.separator);
string = string.replace(/\\/g, '');
if (options.separator) {
string = removeMootSeparators(string, options.separator);
}
if (shouldPrependUnderscore) {
string = `_${string}`;
}
if (shouldAppendDash) {
string = `${string}-`;
}
return string;
}
export function slugifyWithCounter() {
const occurrences = new Map();
const countable = (string, options) => {
string = slugify(string, options);
if (!string) {
return '';
}
const stringLower = string.toLowerCase();
const numberless = occurrences.get(stringLower.replace(/(?:-\d+?)+?$/, '')) || 0;
const counter = occurrences.get(stringLower);
occurrences.set(stringLower, typeof counter === 'number' ? counter + 1 : 1);
const newCounter = occurrences.get(stringLower) || 2;
if (newCounter >= 2 || numberless > 2) {
string = `${string}-${newCounter}`;
}
return string;
};
countable.reset = () => {
occurrences.clear();
};
return countable;
}