@graphql-mesh/string-interpolation 0.0.0

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { Interpolator } from './interpolator';
+export { Interpolator };

package/dist/index.js

@@ -0,0 +1,174 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
+
+const _ = _interopDefault(require('lodash'));
+const jsonPtr = require('json-ptr');
+
+const defaultOptions = {
+    delimiter: ['{', '}'],
+};
+
+const uppercase = value => value.toUpperCase();
+
+const lowercase = value => value.toLowerCase();
+
+const titlecase = value => value.replace(/\w\S*/g, s => s.charAt(0).toUpperCase() + s.substr(1).toLowerCase());
+
+const defaultModifiers = [{
+        key: 'uppercase',
+        transform: uppercase,
+    },
+    {
+        key: 'lowercase',
+        transform: lowercase,
+    },
+    {
+        key: 'title',
+        transform: titlecase,
+    }];
+
+class Interpolator {
+    constructor(options = defaultOptions) {
+        this.options = options;
+        this.modifiers = [];
+        this.aliases = [];
+        this.registerBuiltInModifiers();
+    }
+    registerBuiltInModifiers() {
+        defaultModifiers.forEach(modifier => this.registerModifier(modifier.key, modifier.transform));
+        return this;
+    }
+    get delimiter() {
+        return this.options.delimiter;
+    }
+    delimiterStart() {
+        return this.options.delimiter[0];
+    }
+    delimiterEnd() {
+        return this.options.delimiter[1];
+    }
+    registerModifier(key, transform) {
+        if (!key) {
+            return new Error('Modifiers must have a key');
+        }
+        if (typeof transform !== 'function') {
+            return new Error('Modifiers must have a transformer. Transformers must be a function that returns a value.');
+        }
+        this.modifiers.push({ key: key.toLowerCase(), transform });
+        return this;
+    }
+    parseRules(str) {
+        const regex = `${this.delimiterStart()}([^}]+)${this.delimiterEnd()}`;
+        const execRegex = new RegExp(regex, 'gi');
+        const matches = str.match(execRegex);
+        // const parsableMatches = matches.map((match) => ({ key: removeDelimiter(match), replaceWith: match }));
+        return matches ? this.extractRules(matches) : [];
+    }
+    extractRules(matches) {
+        return matches.map((match) => {
+            const alternativeText = this.getAlternativeText(match);
+            const modifiers = this.getModifiers(match);
+            return {
+                key: this.getKeyFromMatch(match),
+                replace: match,
+                modifiers,
+                alternativeText
+            };
+        });
+    }
+    getKeyFromMatch(match) {
+        const removeReservedSymbols = [':', '|'];
+        return this.removeDelimiter(removeReservedSymbols.reduce((val, sym) => val.indexOf(sym) > 0 ? this.removeAfter(val, sym) : val, match));
+    }
+    removeDelimiter(val) {
+        return val.replace(new RegExp(this.delimiterStart(), 'g'), '').replace(new RegExp(this.delimiterEnd(), 'g'), '');
+    }
+    removeAfter(str, val) {
+        return str.substring(0, str.indexOf(val));
+    }
+    extractAfter(str, val) {
+        return str.substring(str.indexOf(val) + 1);
+    }
+    getAlternativeText(str) {
+        if (str.indexOf(':') > 0) {
+            const altText = this.removeDelimiter(this.extractAfter(str, ':'));
+            if (altText.indexOf('|') > 0) {
+                return this.removeAfter(altText, '|');
+            }
+            return altText;
+        }
+        return '';
+    }
+    getModifiers(str) {
+        if (str.indexOf('|') > 0) {
+            const strModifiers = this.removeDelimiter(this.extractAfter(str, '|')).split(',');
+            return strModifiers.map(modifier => this.getModifier(modifier.toLowerCase()));
+        }
+        return [];
+    }
+    parse(str = '', data = {}) {
+        const rules = this.parseRules(str);
+        if (rules && rules.length > 0) {
+            return this.parseFromRules(str, data, rules);
+        }
+        return str;
+    }
+    parseFromRules(str, data, rules) {
+        return rules.reduce((reducedStr, rule) => this.applyRule(reducedStr, rule, data), str);
+    }
+    applyRule(str, rule, data = {}) {
+        const dataToReplace = this.applyData(rule.key, data);
+        if (dataToReplace) {
+            return str.replace(rule.replace, this.applyModifiers(rule.modifiers, dataToReplace, data));
+        }
+        else if (rule.alternativeText) {
+            return str.replace(rule.replace, this.applyModifiers(rule.modifiers, rule.alternativeText, data));
+        }
+        const defaultModifier = this.applyModifiers(rule.modifiers, rule.key, data);
+        if (defaultModifier === rule.key) {
+            return str.replace(rule.replace, '');
+        }
+        return str.replace(rule.replace, defaultModifier);
+    }
+    getFromAlias(key) {
+        return this.aliases.find(alias => alias.key.toLowerCase() === key.toLowerCase());
+    }
+    applyData(key, data) {
+        const [prop, ptr] = key.split('#');
+        const propData = _.get(data, prop);
+        if (ptr) {
+            return jsonPtr.JsonPointer.get(propData, ptr);
+        }
+        return propData;
+    }
+    getModifier(key) {
+        return this.modifiers.find(modifier => modifier.key === key);
+    }
+    applyModifiers(modifiers, str, rawData) {
+        try {
+            const transformers = modifiers.map(modifier => modifier && modifier.transform);
+            return transformers.reduce((str, transform) => transform ? transform(str, rawData) : str, str);
+        }
+        catch (e) {
+            return str;
+        }
+    }
+    addAlias(key, ref) {
+        if (typeof ref === 'function') {
+            this.aliases.push({ key, ref: ref() });
+        }
+        else {
+            this.aliases.push({ key, ref });
+        }
+        return this;
+    }
+    removeAlias(key) {
+        this.aliases = this.aliases.filter(alias => alias.key !== key);
+        return this;
+    }
+}
+
+exports.Interpolator = Interpolator;

package/dist/index.mjs

@@ -0,0 +1,168 @@
+import _ from 'lodash';
+import { JsonPointer } from 'json-ptr';
+
+const defaultOptions = {
+    delimiter: ['{', '}'],
+};
+
+const uppercase = value => value.toUpperCase();
+
+const lowercase = value => value.toLowerCase();
+
+const titlecase = value => value.replace(/\w\S*/g, s => s.charAt(0).toUpperCase() + s.substr(1).toLowerCase());
+
+const defaultModifiers = [{
+        key: 'uppercase',
+        transform: uppercase,
+    },
+    {
+        key: 'lowercase',
+        transform: lowercase,
+    },
+    {
+        key: 'title',
+        transform: titlecase,
+    }];
+
+class Interpolator {
+    constructor(options = defaultOptions) {
+        this.options = options;
+        this.modifiers = [];
+        this.aliases = [];
+        this.registerBuiltInModifiers();
+    }
+    registerBuiltInModifiers() {
+        defaultModifiers.forEach(modifier => this.registerModifier(modifier.key, modifier.transform));
+        return this;
+    }
+    get delimiter() {
+        return this.options.delimiter;
+    }
+    delimiterStart() {
+        return this.options.delimiter[0];
+    }
+    delimiterEnd() {
+        return this.options.delimiter[1];
+    }
+    registerModifier(key, transform) {
+        if (!key) {
+            return new Error('Modifiers must have a key');
+        }
+        if (typeof transform !== 'function') {
+            return new Error('Modifiers must have a transformer. Transformers must be a function that returns a value.');
+        }
+        this.modifiers.push({ key: key.toLowerCase(), transform });
+        return this;
+    }
+    parseRules(str) {
+        const regex = `${this.delimiterStart()}([^}]+)${this.delimiterEnd()}`;
+        const execRegex = new RegExp(regex, 'gi');
+        const matches = str.match(execRegex);
+        // const parsableMatches = matches.map((match) => ({ key: removeDelimiter(match), replaceWith: match }));
+        return matches ? this.extractRules(matches) : [];
+    }
+    extractRules(matches) {
+        return matches.map((match) => {
+            const alternativeText = this.getAlternativeText(match);
+            const modifiers = this.getModifiers(match);
+            return {
+                key: this.getKeyFromMatch(match),
+                replace: match,
+                modifiers,
+                alternativeText
+            };
+        });
+    }
+    getKeyFromMatch(match) {
+        const removeReservedSymbols = [':', '|'];
+        return this.removeDelimiter(removeReservedSymbols.reduce((val, sym) => val.indexOf(sym) > 0 ? this.removeAfter(val, sym) : val, match));
+    }
+    removeDelimiter(val) {
+        return val.replace(new RegExp(this.delimiterStart(), 'g'), '').replace(new RegExp(this.delimiterEnd(), 'g'), '');
+    }
+    removeAfter(str, val) {
+        return str.substring(0, str.indexOf(val));
+    }
+    extractAfter(str, val) {
+        return str.substring(str.indexOf(val) + 1);
+    }
+    getAlternativeText(str) {
+        if (str.indexOf(':') > 0) {
+            const altText = this.removeDelimiter(this.extractAfter(str, ':'));
+            if (altText.indexOf('|') > 0) {
+                return this.removeAfter(altText, '|');
+            }
+            return altText;
+        }
+        return '';
+    }
+    getModifiers(str) {
+        if (str.indexOf('|') > 0) {
+            const strModifiers = this.removeDelimiter(this.extractAfter(str, '|')).split(',');
+            return strModifiers.map(modifier => this.getModifier(modifier.toLowerCase()));
+        }
+        return [];
+    }
+    parse(str = '', data = {}) {
+        const rules = this.parseRules(str);
+        if (rules && rules.length > 0) {
+            return this.parseFromRules(str, data, rules);
+        }
+        return str;
+    }
+    parseFromRules(str, data, rules) {
+        return rules.reduce((reducedStr, rule) => this.applyRule(reducedStr, rule, data), str);
+    }
+    applyRule(str, rule, data = {}) {
+        const dataToReplace = this.applyData(rule.key, data);
+        if (dataToReplace) {
+            return str.replace(rule.replace, this.applyModifiers(rule.modifiers, dataToReplace, data));
+        }
+        else if (rule.alternativeText) {
+            return str.replace(rule.replace, this.applyModifiers(rule.modifiers, rule.alternativeText, data));
+        }
+        const defaultModifier = this.applyModifiers(rule.modifiers, rule.key, data);
+        if (defaultModifier === rule.key) {
+            return str.replace(rule.replace, '');
+        }
+        return str.replace(rule.replace, defaultModifier);
+    }
+    getFromAlias(key) {
+        return this.aliases.find(alias => alias.key.toLowerCase() === key.toLowerCase());
+    }
+    applyData(key, data) {
+        const [prop, ptr] = key.split('#');
+        const propData = _.get(data, prop);
+        if (ptr) {
+            return JsonPointer.get(propData, ptr);
+        }
+        return propData;
+    }
+    getModifier(key) {
+        return this.modifiers.find(modifier => modifier.key === key);
+    }
+    applyModifiers(modifiers, str, rawData) {
+        try {
+            const transformers = modifiers.map(modifier => modifier && modifier.transform);
+            return transformers.reduce((str, transform) => transform ? transform(str, rawData) : str, str);
+        }
+        catch (e) {
+            return str;
+        }
+    }
+    addAlias(key, ref) {
+        if (typeof ref === 'function') {
+            this.aliases.push({ key, ref: ref() });
+        }
+        else {
+            this.aliases.push({ key, ref });
+        }
+        return this;
+    }
+    removeAlias(key) {
+        this.aliases = this.aliases.filter(alias => alias.key !== key);
+        return this;
+    }
+}
+
+export { Interpolator };

package/dist/interpolator.d.ts

@@ -0,0 +1,32 @@
+export class Interpolator {
+    constructor(options?: {
+        delimiter: string[];
+    });
+    options: {
+        delimiter: string[];
+    };
+    modifiers: any[];
+    aliases: any[];
+    registerBuiltInModifiers(): Interpolator;
+    get delimiter(): string[];
+    delimiterStart(): string;
+    delimiterEnd(): string;
+    registerModifier(key: any, transform: any): Error | Interpolator;
+    parseRules(str: any): any;
+    extractRules(matches: any): any;
+    getKeyFromMatch(match: any): any;
+    removeDelimiter(val: any): any;
+    removeAfter(str: any, val: any): any;
+    extractAfter(str: any, val: any): any;
+    getAlternativeText(str: any): any;
+    getModifiers(str: any): any;
+    parse(str?: string, data?: {}): any;
+    parseFromRules(str: any, data: any, rules: any): any;
+    applyRule(str: any, rule: any, data?: {}): any;
+    getFromAlias(key: any): any;
+    applyData(key: any, data: any): any;
+    getModifier(key: any): any;
+    applyModifiers(modifiers: any, str: any, rawData: any): any;
+    addAlias(key: any, ref: any): Interpolator;
+    removeAlias(key: any): Interpolator;
+}

package/dist/modifiers/index.d.ts

@@ -0,0 +1,4 @@
+export const defaultModifiers: {
+    key: string;
+    transform: (value: any) => any;
+}[];

package/dist/modifiers/lowercase.d.ts

@@ -0,0 +1 @@
+export function lowercase(value: any): any;

package/dist/modifiers/title.d.ts

@@ -0,0 +1 @@
+export function titlecase(value: any): any;

package/dist/modifiers/uppercase.d.ts

@@ -0,0 +1 @@
+export function uppercase(value: any): any;

package/dist/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@graphql-mesh/string-interpolation",
+  "version": "0.0.0",
+  "description": "Dynamic string manipulation",
+  "sideEffects": false,
+  "dependencies": {
+    "json-ptr": "3.1.0",
+    "lodash": "^4.17.21"
+  },
+  "repository": {
+    "type": "git",
+    "url": "Urigo/graphql-mesh",
+    "directory": "packages/string-interpolation"
+  },
+  "author": "Arda TANRIKULU <ardatanrikulu@gmail.com>",
+  "main": "index.js",
+  "module": "index.mjs",
+  "typings": "index.d.ts",
+  "typescript": {
+    "definition": "index.d.ts"
+  },
+  "exports": {
+    ".": {
+      "require": "./index.js",
+      "import": "./index.mjs"
+    },
+    "./*": {
+      "require": "./*.js",
+      "import": "./*.mjs"
+    },
+    "./package.json": "./package.json"
+  }
+}

package/dist/statics/DefaultOptions.d.ts

@@ -0,0 +1,3 @@
+export namespace defaultOptions {
+    const delimiter: string[];
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@graphql-mesh/string-interpolation",
+  "version": "0.0.0",
+  "description": "Dynamic string manipulation",
+  "sideEffects": false,
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "typings": "dist/index.d.ts",
+  "typescript": {
+    "definition": "dist/index.d.ts"
+  },
+  "exports": {
+    ".": {
+      "require": "./dist/index.js",
+      "import": "./dist/index.mjs"
+    },
+    "./*": {
+      "require": "./dist/*.js",
+      "import": "./dist/*.mjs"
+    }
+  },
+  "dependencies": {
+    "json-ptr": "3.1.0",
+    "lodash": "^4.17.21"
+  },
+  "author": "Arda TANRIKULU <ardatanrikulu@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "Urigo/graphql-mesh",
+    "directory": "packages/string-interpolation"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+import { Interpolator } from './interpolator';
+
+export { Interpolator };

package/src/interpolator.js

@@ -0,0 +1,171 @@
+import { defaultOptions } from './statics/DefaultOptions';
+import _ from 'lodash';
+import { defaultModifiers } from './modifiers';
+import { JsonPointer } from 'json-ptr';
+
+export class Interpolator {
+  constructor(options = defaultOptions) {
+    this.options = options;
+    this.modifiers = [];
+    this.aliases = [];
+    this.registerBuiltInModifiers();
+  }
+
+  registerBuiltInModifiers() {
+    defaultModifiers.forEach(modifier => this.registerModifier(modifier.key, modifier.transform));
+    return this;
+  }
+
+  get delimiter() {
+    return this.options.delimiter;
+  }
+
+  delimiterStart() {
+    return this.options.delimiter[0];
+  }
+
+  delimiterEnd() {
+    return this.options.delimiter[1];
+  }
+
+  registerModifier(key, transform) {
+    if (!key) {
+      return new Error('Modifiers must have a key');
+    }
+
+    if (typeof transform !== 'function') {
+      return new Error('Modifiers must have a transformer. Transformers must be a function that returns a value.');
+    }
+
+    this.modifiers.push({key: key.toLowerCase(), transform});
+    return this;
+  }
+
+  parseRules(str) {
+    const regex = `${this.delimiterStart()}([^}]+)${this.delimiterEnd()}`;
+    const execRegex = new RegExp(regex, 'gi');
+    const matches = str.match(execRegex);
+
+    // const parsableMatches = matches.map((match) => ({ key: removeDelimiter(match), replaceWith: match }));
+    return matches ? this.extractRules(matches) : [];
+  }
+
+  extractRules(matches) {
+    return matches.map((match) => {
+      const alternativeText = this.getAlternativeText(match);
+      const modifiers = this.getModifiers(match);
+      return {
+        key: this.getKeyFromMatch(match),
+        replace: match,
+        modifiers,
+        alternativeText
+      }
+    })
+  }
+
+  getKeyFromMatch(match) {
+    const removeReservedSymbols = [':', '|'];
+    return this.removeDelimiter(removeReservedSymbols.reduce((val, sym) => val.indexOf(sym) > 0 ? this.removeAfter(val, sym) : val, match));
+  }
+
+  removeDelimiter(val) {
+    return val.replace(new RegExp(this.delimiterStart(), 'g'), '').replace(new RegExp(this.delimiterEnd(), 'g'), '');
+  }
+
+  removeAfter(str, val) {
+    return str.substring(0, str.indexOf(val));
+  }
+
+  extractAfter(str, val) {
+    return str.substring(str.indexOf(val) + 1);
+  }
+
+  getAlternativeText(str) {
+    if (str.indexOf(':') > 0) {
+      const altText = this.removeDelimiter(this.extractAfter(str, ':'));
+      if (altText.indexOf('|') > 0) {
+        return this.removeAfter(altText, '|');
+      }
+      return altText;
+    }
+
+    return '';
+  }
+
+  getModifiers(str) {
+    if (str.indexOf('|') > 0) {
+      const strModifiers = this.removeDelimiter(this.extractAfter(str, '|')).split(',');
+      return strModifiers.map(modifier => this.getModifier(modifier.toLowerCase()));
+    }
+
+    return [];
+  }
+
+  parse(str = '', data = {}) {
+    const rules = this.parseRules(str);
+    if (rules && rules.length > 0) {
+      return this.parseFromRules(str, data, rules);
+    }
+
+    return str;
+  }
+
+  parseFromRules(str, data, rules) {
+    return rules.reduce((reducedStr, rule) => this.applyRule(reducedStr, rule, data), str);
+  }
+
+  applyRule(str, rule, data = {}) {
+    const dataToReplace = this.applyData(rule.key, data);
+    if (dataToReplace) {
+      return str.replace(rule.replace, this.applyModifiers(rule.modifiers, dataToReplace, data));
+    } else if (rule.alternativeText) {
+      return str.replace(rule.replace, this.applyModifiers(rule.modifiers, rule.alternativeText, data));
+    }
+
+    const defaultModifier = this.applyModifiers(rule.modifiers, rule.key, data);
+    if (defaultModifier === rule.key) {
+      return str.replace(rule.replace, '');
+    }
+    return str.replace(rule.replace, defaultModifier);
+  }
+
+  getFromAlias(key) {
+    return this.aliases.find(alias => alias.key.toLowerCase() === key.toLowerCase());
+  }
+
+  applyData(key, data) {
+    const [prop, ptr] = key.split('#');
+    const propData = _.get(data, prop);
+    if (ptr) {
+      return JsonPointer.get(propData, ptr);
+    }
+    return propData;
+  }
+
+  getModifier(key) {
+    return this.modifiers.find(modifier => modifier.key === key);
+  }
+
+  applyModifiers(modifiers, str, rawData) {
+    try {
+      const transformers = modifiers.map(modifier => modifier && modifier.transform);
+      return transformers.reduce((str, transform) => transform ? transform(str, rawData) : str, str);
+    } catch (e) {
+      return str;
+    }
+  }
+
+  addAlias(key, ref) {
+    if (typeof ref === 'function'){
+      this.aliases.push({key, ref: ref() });
+    } else {
+      this.aliases.push({ key, ref });
+    }
+    return this;
+  }
+
+  removeAlias(key) {
+    this.aliases = this.aliases.filter(alias => alias.key !== key);
+    return this;
+  }
+}

package/src/modifiers/index.js

@@ -0,0 +1,16 @@
+import { uppercase } from './uppercase';
+import { lowercase } from './lowercase';
+import { titlecase } from './title';
+
+export const defaultModifiers = [{
+  key: 'uppercase',
+  transform: uppercase,
+},
+{
+  key: 'lowercase',
+  transform: lowercase,
+},
+{
+  key: 'title',
+  transform: titlecase,
+}];

package/src/modifiers/lowercase.js

@@ -0,0 +1 @@
+export const lowercase = value => value.toLowerCase();

package/src/modifiers/title.js

@@ -0,0 +1 @@
+export const titlecase = value => value.replace(/\w\S*/g, s => s.charAt(0).toUpperCase() + s.substr(1).toLowerCase());

package/src/modifiers/uppercase.js

@@ -0,0 +1 @@
+export const uppercase = value => value.toUpperCase();

package/src/statics/DefaultOptions.js

@@ -0,0 +1,3 @@
+export const defaultOptions = {
+  delimiter: ['{', '}'],
+}