stringweaver 1.4.2 → 1.4.4

package/src/{genericMethods.js → helpers.js}

@@ -1,111 +1,92 @@
-import {default as randomString, uuid4}  from "./Factories/randomStringFactory.js";
 import interpolate from "./factories/splatESBundle.js";
 import createRegExp from "./Factories/regExpFromMultilineStringFactory.js";
-import createInstance from "./extensions.js";
-import {capitalizerFactory} from "./instanceMethods.js";
-const customMethods = {};
+import {default as randomString, uuid4}  from "./Factories/randomStringFactory.js";
+import {CustomStringConstructor} from "./CTORCreator.js";
+import {parseCamelcase, parseKebabCase, parseSnakeCase, ucFirst, wordsFirstUp} from "./instanceMethods.js";
 const quotingStyles = defineQuotingStyles();
+const deprecatedRE = /symbol|anchor|big|blink|bold|fixed|fontsize|fontcolor|italics|link|small|strike|sup|sub/i
 
 export {
-  customMethods,
-  CustomStringConstructor,
-  isNumber,
-  isArrayOf,
-  quotGetters4Instance,
-  getStringValue,
-  escapeRE,
-  resolveTemplateString,
-  clone,
-  interpolate,
-  quotingStyles,
-  createRegExp,
+  capitalizerFactory, createExtendedCTOR, createRegExp, defineQuotingStyles,
+  deprecatedRE, getStringValue, escapeRE, infoValue, interpolate, isArrayOf, isNumber,
+  randomString, resolveTemplateString, retrieveQuotInfo, quotGetters4Instance, uuid4,
 };
 
-createExtendedCTOR(CustomStringConstructor, customMethods);
-
-function CustomStringConstructor(str, ...args) {
-  const instance = createInstance({initialstring: resolveTemplateString(str, ...args)});
-  Object.defineProperty( instance,
-    `constructor`, { get() { return CustomStringConstructor; }, enumerable: false}
-  );
-  return Object.freeze(instance);
-}
-
-function resolveTemplateString(str, ...args) {
-  return str?.raw
-    ? String.raw({ raw: str }, ...args)
-    : getStringValue(str).length ? str : "";
+function defineQuotingStyles() {
+  // see https://en.wikipedia.org/wiki/Quotation_mark
+  const quots = {
+    backtick: ["`", "`"],
+    parentheses: [`(`, `)`],
+    curlyBrackets: [`{`, `}`],
+    curlyDoubleInward: [`”`, `“`],
+    curlyDouble: [`“`, `”`],
+    curlyDoubleEqual: [`“`, `“`],
+    curlyLHDouble: [`„`, `”`],
+    curlyLHDoubleInward: [`„`, `“`],
+    curlyLHSingle: [`‚`, `’`],
+    curlyLHSingleInward: [`‚`, `‘`],
+    curlySingle: [`‛`, `’`],
+    curlySingleEqual: [`‛`, `‛`],
+    curlySingleInward: [`’`, `‛`],
+    double: [`"`, `"`],
+    guillemets: [`«`, `»`],
+    guillemetsInward: [`»`, `«`],
+    guillemetsSingle: [`‹`, `›`],
+    guillemetsSingleInward: [`›`, `‹`],
+    single: [`'`, `'`],
+    squareBrackets: [`[`, `]`],
+  };
+  quots.re = escapeRE([...new Set(
+    Object.values(quots)
+      .filter(v => Array.isArray(v))
+      .flat())].join(``), "g");
+  return quots;
 }
 
-function isArrayOf(type, value, includeInstances = true) {
-  return Array.isArray(value) && value.length > 0 && !value.find(v => checkType(type, v, includeInstances));
+function escapeRE(reString, modifiers) {
+  return new RegExp(reString.replace(/\p{S}|\p{P}/gu, a => `\\${a}`), modifiers);
 }
 
-function clone(instance) {
-  const newInstance = CustomStringConstructor(instance.value);
-  newInstance.history = [...instance.history];
-  return newInstance;
-}
 
 function getStringValue(string) {
   return string?.value || (string?.constructor === String && string) || ``;
 }
 
-function isNumber(value) {
-  return value?.constructor === Number && !Number.isNaN(value);
-}
-
-function escapeRE(reString, modifiers) {
-  return new RegExp(reString.replace(/\p{S}|\p{P}/gu, a => `\\${a}`), modifiers);
+function isArrayOf(type, value, includeInstances = true) {
+  return Array.isArray(value) && value.length > 0 &&
+    !value.find(v => checkType(type, v, includeInstances));
 }
 
-function escape4RE(reString) {
-  return reString.replace(/\p{S}|\p{P}/gu, a => `\\${a}`);
+function isNumber(value) {
+  return value?.constructor === Number && !Number.isNaN(value);
 }
 
 function infoValue(key, infoValue) {
   return `${key} (${infoValue})`;
 }
 
-function getPlainValues() {
-  const capitalizerKeys = Object.keys(capitalizerFactory());
-  return {
-    value: `getter/setter`,
-    clone: `chainable getter`,
-    notEmpty: `chainable getter|undefined`,
-    quote: `Object. See [constructor].quoteInfo`,
-    capitalize: `getter. Object with chainable getters: [${capitalizerKeys.join(`, `)}]`,
-  };
+function checkType(type, item, includeInstances) {
+  return type === String && includeInstances
+    ? item?.constructor !== CustomStringConstructor && item?.constructor !== type
+    : item?.constructor !== type;
 }
 
-function getSWInformation(notChainable) {
-  const firstLines = CustomStringConstructor(decode());
-  const plainValues = getPlainValues();
+function resolveTemplateString(str, ...args) {
+  return str?.raw
+    ? String.raw({ raw: str }, ...args)
+    : getStringValue(str).length ? str : "";
+}
 
-  return firstLines.split(/\n/)
-    .concat(
-      Object.entries(Object.getOwnPropertyDescriptors(firstLines))
-      .sort(([keyA], [keyB]) => keyA.localeCompare(keyB))
-      .map(([key, descriptr]) => {
-        const isChainable = !notChainable.find(k => k === key);
-        const isGetter = 'get' in descriptr;
-        const isMethod = 'value' in descriptr;
-        const isNative = key in String.prototype;
-        const isPlainValue = !isNative && key in plainValues;
-        const custom = key in customMethods ? ` *custom*` : ``;
-        const getter = isGetter && isChainable ? `chainable getter${custom}` : `getter`;
-        const method = isMethod && isChainable ? `chainable method${custom}` : `method`;
-        const native = isNative && `${descriptr.get ? `getter` : `method`} (override)`;
+function retrieveQuotInfo(instanceQuotGetters4Info, ctor) {
+  return Object.entries(Object.getOwnPropertyDescriptors(instanceQuotGetters4Info.value))
+    .sort( (a,b) => a[0].localeCompare(b[0]) )
+    .reduce((acc, [k,]) => {
+      if (k === `remove`) { return [...acc, `[instance].quote.remove (only predefined)`]; }
+      if (k === `custom`) { return [...acc, `[instance].quote.custom(start:string, end:string)`]; }
 
-        switch (true) {
-            case isPlainValue: return infoValue(key, plainValues[key]);
-            case isNative: return infoValue(key, native);
-            case isMethod: return infoValue(key, method);
-            case isGetter: return infoValue(key, getter);
-         }
-        }
-      )
-    );
+      const val = ctor(`[instance]`).quote[k];
+      return [...acc, `[instance].quote.${k} ( ${val} )`];
+    }, []);
 }
 
 function quotGetters4Instance(instance, wrap) {
@@ -139,58 +120,38 @@ function quotGetters4Instance(instance, wrap) {
   };
 }
 
-function decode() {
-  return atob`Rm9yIHRoZSByZWNvcmQ6CltjbV0gY2hhaW5hYmxlIGdldHRlcnMvbWV0aG9kcyBtb2RpZnkgdGhlIGluc3RhbmNlIHN0cmluZwpbY21dIGluZGV4T2Ygb3ZlcnJpZGVzIHJldHVybnMgW3VuZGVmaW5lZF0gaWYgbm90aGluZyB3YXMgZm91bmQgKHNvIG9uZSBjYW4gdXNlIFtsYXN0SV1pbmRleE9mKFtzb21lIHN0cmluZyB2YWx1ZV0pID8/IDAKW2NtXSBpbmNsdWRlcyBpbmZvcm1hdGlvbiBmb3IgY3VzdG9tIG1ldGhvZHMvZ2V0dGVycyBpZiBhcHBsaWNhYmxl`.replace(/\[cm]/g, `\u2714`);
-}
-
-function defineQuotingStyles() {
-  // see https://en.wikipedia.org/wiki/Quotation_mark
-  const quots = {
-    backtick: ["`", "`"],
-    parentheses: [`(`, `)`],
-    curlyBrackets: [`{`, `}`],
-    curlyDoubleInward: [`”`, `“`],
-    curlyDouble: [`“`, `”`],
-    curlyDoubleEqual: [`“`, `“`],
-    curlyLHDouble: [`„`, `”`],
-    curlyLHDoubleInward: [`„`, `“`],
-    curlyLHSingle: [`‚`, `’`],
-    curlyLHSingleInward: [`‚`, `‘`],
-    curlySingle: [`‛`, `’`],
-    curlySingleEqual: [`‛`, `‛`],
-    curlySingleInward: [`’`, `‛`],
-    double: [`"`, `"`],
-    guillemets: [`«`, `»`],
-    guillemetsInward: [`»`, `«`],
-    guillemetsSingle: [`‹`, `›`],
-    guillemetsSingleInward: [`›`, `‹`],
-    single: [`'`, `'`],
-    squareBrackets: [`[`, `]`],
-  };
-  const regExpValues = escape4RE([...new Set(
-    Object.values(quots)
-      .filter(v => Array.isArray(v))
-      .flat())].join(``));
-  quots.re = RegExp(`^[${regExpValues}]|[${regExpValues}]$`, "g");
-
-  return quots;
-}
-
-function retrieveQuotInfo(instanceQuotGetters4Info, ctor) {
-  return Object.entries(Object.getOwnPropertyDescriptors(instanceQuotGetters4Info.value))
-    .sort( (a,b) => a[0].localeCompare(b[0]) )
-    .reduce((acc, [k,]) => {
-      if (k === `remove`) { return [...acc, `[instance].quote.remove (only predefined)`]; }
-      if (k === `custom`) { return [...acc, `[instance].quote.custom(start:string, end:string)`]; }
-
-      const val = ctor(`[instance]`).quote[k];
-      return [...acc, `[instance].quote.${k} ( ${val} )`];
-    }, []);
+function capitalizerFactory(instance, wrap) {
+  return {
+    get full() {
+      return wrap(instance.value.toUpperCase());
+    },
+    get none() {
+      return wrap(instance.value.toLowerCase());
+    },
+    get camel() {
+      return wrap(parseCamelcase(instance.value));
+    },
+    get snake() {
+      return wrap(parseSnakeCase(instance.value));
+    },
+    get first() {
+      return wrap(ucFirst(instance.value));
+    },
+    get kebab() {
+      return wrap(parseKebabCase(instance.value));
+    },
+    get words() {
+      return wrap(wordsFirstUp(instance.value));
+    },
+    get dashed() {
+      return wrap(parseKebabCase(instance.value));
+    },
+  }
 }
 
 function createExtendedCTOR(ctor, customMethods) {
   const quoteInfo = retrieveQuotInfo(quotGetters4Instance(ctor()), ctor);
-  const swInfo = getSWInformation(`constructor,history,indexOf,toString,value,valueOf,empty`.split(`,`));
+  const swInfo = () => getSWInformation(`constructor,history,indexOf,toString,value,valueOf,empty`.split(`,`), customMethods);
   Symbol.toSB = Symbol(`toStringBuilder`);
   Object.defineProperty(
     String.prototype,
@@ -201,7 +162,6 @@ function createExtendedCTOR(ctor, customMethods) {
     }
   );
 
-
   Object.defineProperties(ctor, {
     create: {
       get() { return ctor(); },
@@ -223,18 +183,18 @@ function createExtendedCTOR(ctor, customMethods) {
           return `addCustom: the property "${name}" exists and can not be redefined`;
         }
 
-        if (name?.constructor === String && method?.constructor === Function && method.length > 0) {
+        if (typeof name === `string` && typeof method === `function` && method.length > 0) {
           customMethods[name] = {method, enumerable, isGetter};
           return `addCustom: the ${isGetter ? `getter` : `method`} named "${name}" is added`;
         }
       }
     },
-    info: { value: swInfo, },
+    info: { get() { return swInfo(); } },
     keys: {
       get() {
         return Object.keys(Object.getOwnPropertyDescriptors(CustomStringConstructor``))
           .sort( (a,b) => a.localeCompare(b) )
-          .map(v => !/constructor|toString|valueOf/.test(v) && v in customMethods ? `${v} *custom*` : v);
+          .map(v => !/constructor|toString|valueOf/.test(v) && Object.hasOwn(customMethods, v) ? `${v} *custom*` : v);
       }
     },
     quoteInfo: { value: quoteInfo },
@@ -250,8 +210,51 @@ function createExtendedCTOR(ctor, customMethods) {
   return;
 }
 
-function checkType(type, item, includeInstances) {
-  return type === String && includeInstances
-    ? item?.constructor !== CustomStringConstructor && item?.constructor !== type
-    : item?.constructor !== type;
+function getSWInformation(notChainable, customMethods) {
+  const firstLines = CustomStringConstructor(getInfoPrefix());
+  const plainValues = getPlainValues();
+
+  return firstLines.split(/\n/)
+    .concat(
+      Object.entries(Object.getOwnPropertyDescriptors(firstLines))
+        .sort(([keyA], [keyB]) => keyA.localeCompare(keyB))
+        .map(([key, descriptr]) => {
+            const isChainable = !notChainable.find(k => k === key);
+            const isGetter = Object.hasOwn(descriptr, `get`);
+            const isMethod = Object.hasOwn(descriptr, `value`);
+            const isNative = Object.hasOwn(String.prototype, key);
+            const isPlainValue = !isNative && Object.hasOwn(plainValues, key);
+            const custom = Object.hasOwn(customMethods, key) ? ` *custom*` : ``;
+            const getter = isGetter && isChainable ? `chainable getter${custom}` : `getter`;
+            const method = isMethod && isChainable ? `chainable method${custom}` : `method`;
+            const native = isNative && `${descriptr.get ? `getter` : `method`} (override)`;
+
+            switch (true) {
+              case isPlainValue: return infoValue(key, plainValues[key]);
+              case isNative: return infoValue(key, native);
+              case isMethod: return infoValue(key, method);
+              case isGetter: return infoValue(key, getter);
+            }
+          }
+        )
+    );
+}
+
+function getPlainValues() {
+  const capitalizerKeys = Object.keys(capitalizerFactory());
+  return {
+    value: `getter/setter`,
+    clone: `chainable getter`,
+    notEmpty: `chainable getter|undefined`,
+    quote: `Object. See [constructor].quoteInfo`,
+    capitalize: `getter. Object with chainable getters: [${capitalizerKeys.join(`, `)}]`,
+  };
+}
+
+function getInfoPrefix() {
+  return atob(
+    `Rm9yIHRoZSByZWNvcmQ6CltjbV0gY2hhaW5hYmxlIGdldHRlcnMvbWV0aG9kcyBtb2RpZnkgdGhlIGluc3RhbmNlIHN0cmluZwpbY21d`+
+    `IGluZGV4T2Ygb3ZlcnJpZGVzIHJldHVybnMgW3VuZGVmaW5lZF0gaWYgbm90aGluZyB3YXMgZm91bmQgKHNvIG9uZSBjYW4gdXNlIFtsYXN0`+
+    `SV1pbmRleE9mKFtzb21lIHN0cmluZyB2YWx1ZV0pID8/IDAKW2NtXSBpbmNsdWRlcyBpbmZvcm1hdGlvbiBmb3IgY3VzdG9tIG1ldGhv`+
+    `ZHMvZ2V0dGVycyBpZiBhcHBsaWNhYmxl`).replace(/\[cm]/g, `\u2714`);
 }

package/src/instanceCreator.js

@@ -0,0 +1,170 @@
+import {
+  format,
+  ucFirst,
+  truncate,
+  trimAll,
+  replaceWords,
+  indexOf,
+  lastIndexOf,
+  insert,
+  append,
+  prefix,
+  getStringValue,
+  quotGetters,
+  surroundWith,
+  parseCamelcase,
+  wordsFirstUp,
+  parseKebabCase,
+  parseSnakeCase,
+  customMethods,
+  isNumber,
+  clone,
+  trim,
+} from "./instanceMethods.js";
+
+import { capitalizerFactory, deprecatedRE } from "./helpers.js";
+
+export default instanceCreator;
+
+function instanceCreator({initialstring} = {}) {
+  let customStringExtensions = Object.create(null, { });
+  let instance = new Proxy(customStringExtensions, getTraps(customStringExtensions));
+  let actualValue = getStringValue(initialstring);
+  let history = [actualValue];
+  const defaultDescriptorProps = {configurable: false, enumerable: false};
+
+  Object.defineProperties( customStringExtensions, {
+    // methods
+    append: { ...defaultDescriptorProps, value(...strings) { return wrap(append(actualValue, ...strings)); } },
+    enclose: { ...defaultDescriptorProps, value(start, end) { return wrap(surroundWith(actualValue, start, end)); } },
+    format: { ...defaultDescriptorProps, value(...tokens) { return wrap(format(actualValue, ...tokens)); } },
+    indexOf: { ...defaultDescriptorProps, value(str) { return indexOf(actualValue, str); } },
+    interpolate: { ...defaultDescriptorProps, value(...tokens) { return wrap(format(actualValue, ...tokens)); } },
+    insert: { ...defaultDescriptorProps, value({ value, values, at } = {}) {
+        return wrap(insert(actualValue, { value, values, at }));
+      }
+    },
+    lastIndexOf: { ...defaultDescriptorProps, value(str) { return lastIndexOf(actualValue, str); } },
+    prefix: { ...defaultDescriptorProps, value(...strings) { return wrap(prefix(actualValue, ...strings)); } },
+    replaceWords: { ...defaultDescriptorProps, value({caseSensitive = false, replacements = {}} = {}) {
+      return wrap(replaceWords(actualValue, { replacements: replacements ?? {}, caseSensitive }));
+    } },
+    toString: { ...defaultDescriptorProps, value() { return actualValue; } },
+    trim: {...defaultDescriptorProps, value(start, end) { return wrap(trim(actualValue, start, end)); } },
+    truncate: { ...defaultDescriptorProps, value({at, html = false, wordBoundary = false} = {}) {
+      return wrap(truncate(actualValue, {at, html, wordBoundary})); } },
+    valueOf: { ...defaultDescriptorProps, value() { return actualValue; } },
+    undoLast: { ...defaultDescriptorProps, value(nSteps) { return undoSteps(nSteps); } },
+
+    // getters
+    camelCase: { ...defaultDescriptorProps, get() { return wrap(parseCamelcase(getStringValue(actualValue))); } },
+    capitalize: { ...defaultDescriptorProps, value: capitalizerFactory(instance, wrap) },
+    clone: { ...defaultDescriptorProps, get() { return clone(instance, customMethods); } },
+    firstUp: { ...defaultDescriptorProps, get() { return wrap(ucFirst(getStringValue(actualValue))); } },
+    history: { ...defaultDescriptorProps, get() { return history; }, set(value) { history = value; } },
+    empty: { ...defaultDescriptorProps, get() { return actualValue.length < 1; } },
+    notEmpty: { ...defaultDescriptorProps, get() { return actualValue.length < 1 ? undefined: instance; } },
+    kebabCase: { ...defaultDescriptorProps, get() { return wrap(parseKebabCase(getStringValue(actualValue))); } },
+    quote: quotGetters(instance, wrap),
+    snakeCase: { ...defaultDescriptorProps, get() { return wrap(parseSnakeCase(getStringValue(actualValue))); } },
+    trimAll: { ...defaultDescriptorProps, get() { return wrap(trimAll(actualValue)); } },
+    trimAllKeepLF: { ...defaultDescriptorProps, get() { return wrap(trimAll(actualValue, true)); } },
+    undoAll: { ...defaultDescriptorProps, get() { return undoAll(); } },
+    undo: { ...defaultDescriptorProps, get() { return undoLast(); } },
+    wordsUCFirst: { ...defaultDescriptorProps, get() { return wrap(wordsFirstUp(getStringValue(actualValue))); } },
+    value: { ...defaultDescriptorProps,
+      get() { return actualValue; },
+      set(value) {
+        const nwValue = getStringValue(value);
+        if (nwValue.length) {
+          actualValue = nwValue;
+          history.push(nwValue);
+        }
+      }
+    },
+  });
+
+  injectCustomMethods(customMethods);
+
+  return instance;
+
+  function getTraps(customExtensions) {
+    return {
+      get( target, key ) {
+        switch(true) {
+          case key === Symbol.for("myType"): return `stringWeaver instance (Proxy)`;
+          case Object.hasOwn(customExtensions, key): return customExtensions[key];
+          case canWrapNative(String(key)): return wrapNative(key);
+          default: return wrapNative(key);
+        }
+      },
+    };
+  }
+
+  function canWrapNative(key) {
+    return !deprecatedRE.test(key)  && Object.hasOwn(String.prototype, key);
+  }
+
+  function wrapNative(key) {
+    return typeof actualValue[key] === `function`
+      ? function(...args) {
+          const result = actualValue[key](...args);
+          return result?.constructor === String ? wrap(actualValue[key](...args)) : result;
+        }
+      : actualValue[key];
+  }
+
+  function undoAll() {
+    while (history.length > 1) { history.pop(); }
+    actualValue = history.at(-1);
+    return wrap(actualValue, false);
+  }
+
+  function undoSteps(steps) {
+    if (!isNumber(steps)) {
+      return wrap(actualValue, false);
+    }
+
+    const historyLen = history.length;
+
+    if (steps >= historyLen || steps < 1) {
+      history = history.slice(0, 1);
+      actualValue = history.at(-1);
+      return wrap(history.at(-1), false);
+    }
+
+    history = history.slice(0, historyLen - steps);
+
+    actualValue = history.at(-1);
+    return wrap(actualValue, false);
+  }
+
+  function undoLast() {
+    if (history.length === 1) {
+      return wrap(history[0]);
+    }
+
+    history.pop();
+    actualValue = history.at(-1);
+    return wrap(actualValue, false);
+  }
+
+  function wrap(result, pushHistory = true) {
+    const changed = actualValue !== result;
+    changed && pushHistory && history.push(result);
+    actualValue = result;
+    return instance;
+  }
+
+  function injectCustomMethods(customMethods) {
+    Object.entries(customMethods).forEach(([methodName, methodContainer]) => {
+      const {enumerable, method, isGetter} = methodContainer;
+      const configurable = false
+      const descriptor = isGetter
+        ? { get() { return wrap(method(instance).value); }, enumerable, configurable }
+        : { value(...args) { return wrap(method(instance, ...args).value); }, enumerable, configurable };
+
+      Object.defineProperty(customStringExtensions, methodName, descriptor);
+    });
+  }
+}

package/src/instanceMethods.js

@@ -1,13 +1,9 @@
+import { customMethods, clone, } from "./CTORCreator.js";
+
 import {
-  isArrayOf,
-  isNumber,
-  quotGetters4Instance as quotGetters,
-  getStringValue,
-  escapeRE,
-  customMethods,
-  interpolate,
-  createRegExp as $RE,
-  clone } from "./genericMethods.js";
+  createRegExp as $RE, getStringValue, isArrayOf, interpolate,
+  isNumber, escapeRE, quotGetters4Instance as quotGetters,
+} from "./helpers.js";
 
 export {
   format,
@@ -30,7 +26,6 @@ export {
   surroundWith,
   customMethods,
   clone,
-  capitalizerFactory,
   trim,
 };
 
@@ -215,32 +210,3 @@ function append(string, ...strings2Append) {
 
   return getStringValue(string);
 }
-
-function capitalizerFactory(instance, wrap) {
-  return {
-    get full() {
-      return wrap(instance.value.toUpperCase());
-    },
-    get none() {
-      return wrap(instance.value.toLowerCase());
-    },
-    get camel() {
-      return wrap(parseCamelcase(instance.value));
-    },
-    get snake() {
-      return wrap(parseSnakeCase(instance.value));
-    },
-    get first() {
-      return wrap(ucFirst(instance.value));
-    },
-    get kebab() {
-      return wrap(parseKebabCase(instance.value));
-    },
-    get words() {
-      return wrap(wordsFirstUp(instance.value));
-    },
-    get dashed() {
-      return wrap(parseKebabCase(instance.value));
-    },
-  }
-}