@uides/stepwise 2.0.0-rc.33 → 2.0.2

package/generators/node_modules/change-case/dist/index.js

@@ -0,0 +1,135 @@
+const SPLIT_LOWER_UPPER_RE = /([\p{Ll}\d])(\p{Lu})/gu;
+const SPLIT_UPPER_UPPER_RE = /(\p{Lu})([\p{Lu}][\p{Ll}])/gu;
+const SPLIT_NUMBER_LOWER_RE = /(\d)(\p{Ll})/gu;
+const SPLIT_LETTER_NUMBER_RE = /(\p{L})(\d)/gu;
+const DEFAULT_STRIP_REGEXP = /[^\p{L}\d]+/giu;
+const SPLIT_REPLACE_VALUE = "$1\0$2";
+const DEFAULT_PREFIX_SUFFIX_CHARACTERS = "";
+function split(value, options) {
+    let result = value.trim();
+    result = result.replace(SPLIT_LOWER_UPPER_RE, SPLIT_REPLACE_VALUE).replace(SPLIT_UPPER_UPPER_RE, SPLIT_REPLACE_VALUE);
+    if (options?.separateNumbers) result = result.replace(SPLIT_NUMBER_LOWER_RE, SPLIT_REPLACE_VALUE).replace(SPLIT_LETTER_NUMBER_RE, SPLIT_REPLACE_VALUE);
+    result = result.replace(DEFAULT_STRIP_REGEXP, "\0");
+    let start = 0;
+    let end = result.length;
+    while("\0" === result.charAt(start))start++;
+    if (start === end) return [];
+    while("\0" === result.charAt(end - 1))end--;
+    return result.slice(start, end).split(/\0/g);
+}
+function noCase(input, options) {
+    const [prefix, value, suffix] = splitPrefixSuffix(input, options);
+    return prefix + split(value, options).map(lowerFactory(options?.locale)).join(options?.delimiter ?? " ") + suffix;
+}
+function camelCase(input, options) {
+    const [prefix, value, suffix] = splitPrefixSuffix(input, options);
+    const lower = lowerFactory(options?.locale);
+    const upper = upperFactory(options?.locale);
+    const transform = options?.mergeAmbiguousCharacters ? capitalCaseTransformFactory(lower, upper) : pascalCaseTransformFactory(lower, upper);
+    return prefix + split(value, options).map((word, index)=>{
+        if (0 === index) return lower(word);
+        return transform(word, index);
+    }).join(options?.delimiter ?? "") + suffix;
+}
+function pascalCase(input, options) {
+    const [prefix, value, suffix] = splitPrefixSuffix(input, options);
+    const lower = lowerFactory(options?.locale);
+    const upper = upperFactory(options?.locale);
+    const transform = options?.mergeAmbiguousCharacters ? capitalCaseTransformFactory(lower, upper) : pascalCaseTransformFactory(lower, upper);
+    return prefix + split(value, options).map(transform).join(options?.delimiter ?? "") + suffix;
+}
+function pascalSnakeCase(input, options) {
+    return capitalCase(input, {
+        delimiter: "_",
+        ...options
+    });
+}
+function capitalCase(input, options) {
+    const [prefix, value, suffix] = splitPrefixSuffix(input, options);
+    const lower = lowerFactory(options?.locale);
+    const upper = upperFactory(options?.locale);
+    return prefix + split(value, options).map(capitalCaseTransformFactory(lower, upper)).join(options?.delimiter ?? " ") + suffix;
+}
+function constantCase(input, options) {
+    const [prefix, value, suffix] = splitPrefixSuffix(input, options);
+    return prefix + split(value, options).map(upperFactory(options?.locale)).join(options?.delimiter ?? "_") + suffix;
+}
+function dotCase(input, options) {
+    return noCase(input, {
+        delimiter: ".",
+        ...options
+    });
+}
+function kebabCase(input, options) {
+    return noCase(input, {
+        delimiter: "-",
+        ...options
+    });
+}
+function pathCase(input, options) {
+    return noCase(input, {
+        delimiter: "/",
+        ...options
+    });
+}
+function sentenceCase(input, options) {
+    const [prefix, value, suffix] = splitPrefixSuffix(input, options);
+    const lower = lowerFactory(options?.locale);
+    const upper = upperFactory(options?.locale);
+    const transform = capitalCaseTransformFactory(lower, upper);
+    return prefix + split(value, options).map((word, index)=>{
+        if (0 === index) return transform(word);
+        return lower(word);
+    }).join(options?.delimiter ?? " ") + suffix;
+}
+function snakeCase(input, options) {
+    return noCase(input, {
+        delimiter: "_",
+        ...options
+    });
+}
+function trainCase(input, options) {
+    return capitalCase(input, {
+        delimiter: "-",
+        ...options
+    });
+}
+function lowerFactory(locale) {
+    return false === locale ? (input)=>input.toLowerCase() : (input)=>input.toLocaleLowerCase(locale);
+}
+function upperFactory(locale) {
+    return false === locale ? (input)=>input.toUpperCase() : (input)=>input.toLocaleUpperCase(locale);
+}
+function capitalCaseTransformFactory(lower, upper) {
+    return (word)=>`${upper(word[0])}${lower(word.slice(1))}`;
+}
+function pascalCaseTransformFactory(lower, upper) {
+    return (word, index)=>{
+        const char0 = word[0];
+        const initial = index > 0 && char0 >= "0" && char0 <= "9" ? "_" + char0 : upper(char0);
+        return initial + lower(word.slice(1));
+    };
+}
+function splitPrefixSuffix(input, options) {
+    const prefixCharacters = options?.prefixCharacters ?? DEFAULT_PREFIX_SUFFIX_CHARACTERS;
+    const suffixCharacters = options?.suffixCharacters ?? DEFAULT_PREFIX_SUFFIX_CHARACTERS;
+    let prefixIndex = 0;
+    let suffixIndex = input.length;
+    while(prefixIndex < input.length){
+        const char = input.charAt(prefixIndex);
+        if (!prefixCharacters.includes(char)) break;
+        prefixIndex++;
+    }
+    while(suffixIndex > prefixIndex){
+        const index = suffixIndex - 1;
+        const char = input.charAt(index);
+        if (!suffixCharacters.includes(char)) break;
+        suffixIndex = index;
+    }
+    return [
+        input.slice(0, prefixIndex),
+        input.slice(prefixIndex, suffixIndex),
+        input.slice(suffixIndex)
+    ];
+}
+export { camelCase, capitalCase, constantCase, dotCase, kebabCase, noCase, pascalCase, pascalSnakeCase, pathCase, sentenceCase, snakeCase, split, trainCase };

package/generators/node_modules/change-case/dist/keys.js

@@ -0,0 +1,28 @@
+import { camelCase, capitalCase, constantCase, dotCase, kebabCase, noCase, pascalCase, pathCase, sentenceCase, snakeCase, trainCase } from "./index.js";
+const isObject = (object)=>null !== object && "object" == typeof object;
+function changeKeysFactory(changeCase) {
+    return function changeKeys(object, depth = 1, options) {
+        if (0 === depth || !isObject(object)) return object;
+        if (Array.isArray(object)) return object.map((item)=>changeKeys(item, depth - 1));
+        const result = Object.create(Object.getPrototypeOf(object));
+        Object.keys(object).forEach((key)=>{
+            const value = object[key];
+            const changedKey = changeCase(key, options);
+            const changedValue = changeKeys(value, depth - 1);
+            result[changedKey] = changedValue;
+        });
+        return result;
+    };
+}
+const keys_camelCase = changeKeysFactory(camelCase);
+const keys_capitalCase = changeKeysFactory(capitalCase);
+const keys_constantCase = changeKeysFactory(constantCase);
+const keys_dotCase = changeKeysFactory(dotCase);
+const keys_trainCase = changeKeysFactory(trainCase);
+const keys_noCase = changeKeysFactory(noCase);
+const keys_kebabCase = changeKeysFactory(kebabCase);
+const keys_pascalCase = changeKeysFactory(pascalCase);
+const keys_pathCase = changeKeysFactory(pathCase);
+const keys_sentenceCase = changeKeysFactory(sentenceCase);
+const keys_snakeCase = changeKeysFactory(snakeCase);
+export { keys_camelCase as camelCase, keys_capitalCase as capitalCase, keys_constantCase as constantCase, keys_dotCase as dotCase, keys_kebabCase as kebabCase, keys_noCase as noCase, keys_pascalCase as pascalCase, keys_pathCase as pathCase, keys_sentenceCase as sentenceCase, keys_snakeCase as snakeCase, keys_trainCase as trainCase };