@graphql-codegen/flutter-freezed 2.11.2-alpha-20221101110911-a036e7a25 → 3.0.0

package/esm/config/pattern.js

@@ -0,0 +1,723 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { arrayWrap, resetIndex, strToList } from '../utils.js';
+/**
+ * @name TypeName
+ * @description represents a single valid GraphQL Type Name used in the GraphQL Schema provided
+ * @exampleMarkdown
+ * ```ts filename:"config.ts"
+ * // returns a TypeName
+ * let typeName: TypeName = TypeName.fromString('Droid');
+ *
+ * // to configure a FactoryBlock, use the `TypeName.fromUnionOfTypeNames(className, factoryName)`
+ * let typeName: TypeName = TypeName.fromUnionOfTypeNames(SearchResult, Droid);
+
+ * // the following will throw an error
+ * // can contain only a single value...
+ * let typeName: TypeName = TypeName.fromString('Droid, Human'); // throws an Error
+ *
+ * // value can not be an empty string...
+ * let typeName: TypeName = TypeName.fromString(''); // throws an Error
+ *
+ * // value must contain only AlphaNumeric characters only...
+ * let typeName: TypeName = TypeName.fromString('Invalid.Name'); // throws an Error
+ * ```
+ */
+export class TypeName {
+    constructor(value) {
+        this._value = value;
+    }
+    get value() {
+        return this._value;
+    }
+    static get allTypeNames() {
+        return '@*TypeNames';
+    }
+}
+TypeName.fromUnionOfTypeNames = (className, factoryName) => new TypeName(`${className.value}_${factoryName.value}`);
+TypeName.fromString = (value) => {
+    if (value === undefined || value.length < 1) {
+        throw new Error('TypeName is the name of a GraphQL Type and it cannot be empty');
+    }
+    else if (/([^a-zA-Z0-9_])/gim.test(value)) {
+        throw new Error('TypeName is the name of a GraphQL Type and it must consist of only AlphaNumeric characters');
+    }
+    return new TypeName(value.trim());
+};
+/**
+ * @name FieldName
+ * @description Represents a single valid name of a field belong to a Graphql Type.
+ * @exampleMarkdown
+ * ```ts filename:"config.ts"
+ * // returns a FieldName
+ * let fieldName: FieldName = FieldName.fromString('id');
+ *
+ * // the following will throw an error
+ * // can contain only a single value...
+ * let fieldName: FieldName = FieldName.fromString('id, name'); // throws an Error
+ *
+ * // value can not be an empty string...
+ * let fieldName: FieldName = FieldName.fromString(''); // throws an Error
+ *
+ * // value must contain only AlphaNumeric characters only...
+ * let fieldName: FieldName = FieldName.fromString('Invalid.Name'); // throws an Error
+ * ```
+ */
+export class FieldName {
+    constructor(value) {
+        this._value = value;
+    }
+    get value() {
+        return this._value;
+    }
+    static get allFieldNames() {
+        return '@*FieldNames';
+    }
+}
+FieldName.fromString = (value) => {
+    if (value === undefined || value.length < 1) {
+        throw new Error('FieldName is the name of a field in a GraphQL Type and it cannot be empty');
+    }
+    else if (/([^a-zA-Z0-9_])/gim.test(value)) {
+        throw new Error('FieldName is the name of a field in a GraphQL Type and it must consist of only AlphaNumeric characters');
+    }
+    return new FieldName(value.trim());
+};
+/**
+ * @name Pattern
+ * @description The base class for TypeNamePattern and FieldNamePattern
+ * @see {@link url TypeNamePattern}
+ * @see {@link url FieldNamePattern}
+ */
+export class Pattern {
+    constructor(value) {
+        this._value = value;
+    }
+    get value() {
+        return this._value;
+    }
+}
+Pattern.fromString = (value) => {
+    if (value === undefined || value.length < 1) {
+        throw new Error('Pattern cannot be created from an empty string');
+    }
+    return new Pattern(value.endsWith(';') ? value : `${value};`);
+};
+// #region attemptMatchAndConfigure
+Pattern.attemptMatchAndConfigure = (pattern, typeName, fieldName) => {
+    if (pattern.value.split(';').filter(_pattern => _pattern.length > 0).length !== 1) {
+        throw new Error('attemptMatchAndConfigure can only handle one pattern at a time... use the `splitPatterns(...)` helper function to split your patterns into a list and loop over the list calling the `attemptMatchAndConfigure(...)`  for each single pattern');
+    }
+    const isTypeNamePattern = (baseName) => {
+        if (fieldName === undefined &&
+            (baseName === 'TypeNames' || baseName === 'AllTypeNames' || baseName === 'AllTypeNamesExcludeTypeNames')) {
+            return true;
+        }
+        return false;
+    };
+    const regexpFor = (baseName) => {
+        return isTypeNamePattern(baseName)
+            ? TypeNamePattern[`regexpFor${baseName}`]
+            : FieldNamePattern[`regexpFor${baseName}`];
+    };
+    const matchAndConfigure = (baseName, pattern, ...args) => {
+        return isTypeNamePattern(baseName)
+            ? TypeNamePattern[`matchAndConfigure${baseName}`](pattern, ...args)
+            : FieldNamePattern[`matchAndConfigure${baseName}`](pattern, ...args); // check if fieldName is passed in ...args
+    };
+    const matchList = Pattern.getMatchList(fieldName === undefined ? 'TypeNamePattern' : 'FieldNamePattern');
+    for (let i = 0; i < matchList.length; i++) {
+        const baseName = matchList[i];
+        if (regexpFor(baseName).test(pattern.value)) {
+            return matchAndConfigure(baseName, pattern, typeName, fieldName);
+        }
+    }
+    return undefined;
+};
+//#endregion
+//#region composePatterns
+Pattern.compose = (data) => {
+    if (data.length < 1) {
+        throw new Error('Pattern cannot be created... an empty array was passed as parameter');
+    }
+    return Pattern.fromString(data.map(pattern => pattern.value).join(''));
+};
+//#endregion
+//#region split
+Pattern.split = (pattern) => {
+    return pattern.value
+        .split(';')
+        .filter(_pattern => _pattern.length > 0)
+        .map(_pattern => Pattern.fromString(_pattern));
+};
+//#endregion
+//#region helper methods
+Pattern.getMatchList = (patternType) => {
+    const baseNamesForTypeNamePattern = Object.getOwnPropertyNames(TypeNamePattern)
+        .filter(property => TypeNamePattern[property] instanceof RegExp)
+        .map(regexpForName => regexpForName.slice(9));
+    const baseNamesForFieldNamePattern = Object.getOwnPropertyNames(FieldNamePattern)
+        .filter(property => FieldNamePattern[property] instanceof RegExp)
+        .map(regexpForName => regexpForName.slice(9));
+    return patternType === 'TypeNamePattern'
+        ? baseNamesForTypeNamePattern
+        : patternType === 'FieldNamePattern'
+            ? baseNamesForFieldNamePattern
+            : [...baseNamesForTypeNamePattern, ...baseNamesForFieldNamePattern];
+};
+//#endregion
+/**
+ * finds the last pattern that configures the typeName and/or fieldName given
+ * @param pattern
+ * @param typeName
+ * @param fieldName
+ * @returns true if a pattern marks the typeName and or fieldName given to be configured, otherwise false
+ */
+Pattern.findLastConfiguration = (pattern, typeName, fieldName) => {
+    const key = fieldName ? `${typeName.value}.${fieldName.value}` : typeName.value;
+    return Pattern.split(pattern)
+        .map(pattern => {
+        var _a;
+        const result = Pattern.attemptMatchAndConfigure(pattern, typeName, fieldName);
+        return (_a = result === null || result === void 0 ? void 0 : result[key]) === null || _a === void 0 ? void 0 : _a.shouldBeConfigured;
+    })
+        .filter(value => value !== undefined)
+        .reduce((_acc, value) => value, false);
+};
+/**
+ *  @name TypeNamePattern
+ *
+ * @description A compact string of patterns used in the config for granular configuration of Graphql Types.
+ *
+ * The string can contain one or more patterns, each pattern ends with a semi-colon (`;`).
+ *
+ * To apply an option to all Graphql Types or all fields, use the allTypeNames (`@*TypeNames`) tokens.
+ *
+ * Wherever you use the allTypeNames token, know very well that you can make some exceptions. After all, to every rule, there is an exception.
+ *
+ * A **square bracket** (`[]`) is used to specify what should be included and a **negated square bracket** (`-[]`) is used to specify what should be excluded.
+ *
+ * Manually typing out a pattern may be prone to typos resulting in invalid patterns therefore the [`TypeNamePattern`]() class exposes some builder methods to be used in the plugin config file.
+ *
+ * ## Available Builder Methods and the patterns they make
+ * ```ts
+ * const Droid = TypeName.fromString('Droid');
+ * const Starship = TypeName.fromString('Starship');
+ * const Human = TypeName.fromString('Human');
+ * const Movie = TypeName.fromString('Movie');
+
+ *
+ * // Configuring specific Graphql Types
+ * const pattern = TypeNamePattern.forTypeNames([Droid, Starship]);
+ * console.log(pattern); // "Droid;Starship;"
+ *
+ * // Configuring all Graphql Types
+ * const pattern = TypeNamePattern.forAllTypeNames();
+ * console.log(pattern); // "@*TypeNames;"
+
+ * // Configuring all Graphql Types except those specified in the exclusion list of TypeNames
+ * const pattern = TypeNamePattern.forAllTypeNamesExcludeTypeNames([Droid, Starship]);
+ * console.log(pattern); // "@*TypeNames-[Droid,Starship];"
+ *
+ */
+export class TypeNamePattern extends Pattern {
+    constructor(value) {
+        super(value);
+    }
+}
+//#region `'TypeName;AnotherTypeName;'`
+TypeNamePattern.forTypeNames = (typeNames) => {
+    typeNames = arrayWrap(typeNames);
+    if (typeNames.length < 1) {
+        throw new Error('Pattern cannot be created... No TypeNames were specified');
+    }
+    return TypeNamePattern.fromString(arrayWrap(typeNames)
+        .map(typeName => `${typeName.value};`)
+        .join(''));
+};
+TypeNamePattern.regexpForTypeNames = /\b(?!TypeNames|FieldNames\b)(?<typeName>\w+;)/gim; // TODO: fix this: regexp.test('@*TypeName;') returns true which shouldn't happen
+TypeNamePattern.matchAndConfigureTypeNames = (pattern, typeName) => {
+    const regexp = TypeNamePattern.regexpForTypeNames;
+    resetIndex(regexp);
+    let result;
+    const matchAndConfigure = {};
+    while ((result = regexp.exec(pattern.value)) !== null) {
+        const _typeName = result.groups.typeName.replace(';', '');
+        const key = _typeName;
+        const matchFound = _typeName === typeName.value;
+        const shouldBeConfigured = matchFound;
+        matchAndConfigure[key] = { matchFound, shouldBeConfigured };
+    }
+    resetIndex(regexp);
+    return matchAndConfigure;
+};
+//#endregion
+//#region `'@*TypeNames;'`
+TypeNamePattern.forAllTypeNames = () => Pattern.fromString(TypeName.allTypeNames);
+TypeNamePattern.regexpForAllTypeNames = /(?<allTypeNames>@\*TypeNames;)/gim;
+TypeNamePattern.matchAndConfigureAllTypeNames = (pattern, typeName) => {
+    const regexp = TypeNamePattern.regexpForAllTypeNames;
+    resetIndex(regexp);
+    const matchAndConfigure = {};
+    const key = typeName.value;
+    const matchFound = regexp.test(pattern.value);
+    const shouldBeConfigured = matchFound;
+    matchAndConfigure[key] = { matchFound, shouldBeConfigured };
+    resetIndex(regexp);
+    return matchAndConfigure;
+};
+//#endregion
+//#region `'@*TypeNames-[excludeTypeNames];'`
+TypeNamePattern.forAllTypeNamesExcludeTypeNames = (typeNames) => {
+    typeNames = arrayWrap(typeNames);
+    if (typeNames.length < 1) {
+        throw new Error('Pattern cannot be created... No TypeNames were excluded');
+    }
+    const _typeNames = typeNames.map(typeName => typeName.value).join();
+    return Pattern.fromString(`${TypeName.allTypeNames}-[${_typeNames}];`);
+};
+TypeNamePattern.regexpForAllTypeNamesExcludeTypeNames = /@\*TypeNames-\[\s*(?<typeNames>(\w+,?\s*)*)\];/gim;
+TypeNamePattern.matchAndConfigureAllTypeNamesExcludeTypeNames = (pattern, typeName) => {
+    const regexp = TypeNamePattern.regexpForAllTypeNamesExcludeTypeNames;
+    resetIndex(regexp);
+    let result;
+    const matchAndConfigure = {};
+    // typeNames that were excluded...
+    while ((result = regexp.exec(pattern.value)) !== null) {
+        const _typeNames = strToList(result.groups.typeNames);
+        _typeNames.forEach(_typeName => {
+            const key = _typeName;
+            const matchFound = true;
+            const shouldBeConfigured = false;
+            matchAndConfigure[key] = { matchFound, shouldBeConfigured };
+        });
+    }
+    // interpret global pattern: if typeName is not excluded ...
+    const key = typeName.value;
+    if (matchAndConfigure[key] === undefined) {
+        matchAndConfigure[key] = { matchFound: false, shouldBeConfigured: true };
+    }
+    resetIndex(regexp);
+    return matchAndConfigure;
+};
+/**
+ *  @name FieldNamePattern
+ *
+ * @description A compact string of patterns used in the config for granular configuration the fields of a Graphql Type
+ *
+ * The string can contain one or more patterns, each pattern ends with a semi-colon (`;`).
+ *
+ * A dot (`.`) is used to separate the TypeName from the FieldNames in each pattern.
+ *
+ * To apply an option to all Graphql Types or all fields, use the allTypeNames (`@*TypeNames`) and allFieldNames (`@*FieldNames`) tokens respectively.
+ *
+ * Wherever you use the allTypeNames and the allFieldNames, know very well that you can make some exceptions. After all, to every rule, there is an exception.
+ *
+ * A **square bracket** (`[]`) is used to specify what should be included and a **negated square bracket** (`-[]`) is used to specify what should be excluded.
+ *
+ * Manually typing out a pattern may be prone to typos resulting in invalid patterns therefore the [`FieldName`]() class exposes some builder methods to be used in your plugin config file.
+ *
+ * ## Available Builder Methods and the patterns they make
+ * ```ts
+ * const Droid = TypeName.fromString('Droid');
+ * const Starship = TypeName.fromString('Starship');
+ * const Human = TypeName.fromString('Human');
+ * const Movie = TypeName.fromString('Movie');
+ *
+ * const id = FieldName.fromString('id');
+ * const name = FieldName.fromString('name');
+ * const friends = FieldName.fromString('friends');
+ * const friend = FieldName.fromString('friend');
+ * const title = FieldName.fromString('title');
+ * const episode = FieldName.fromString('episode');
+ * const length = FieldName.fromString('length');
+ *
+ * // Configuring specific fields of a specific Graphql Type
+ * const pattern = FieldNamePattern.forFieldNamesOfTypeName([
+ *   [Droid, [id, name, friends]], // individual
+ *   [Human, [id, name, title]], // individual
+ *   [Starship, [name, length]], // individual
+ * ]);
+ * console.log(pattern); // "Droid.[id,name,friends];Human.[id,name,title];Starship.[name,length];"
+ *
+ * // Configuring all fields of a specific Graphql Type
+ * const pattern = FieldNamePattern.forAllFieldNamesOfTypeName([Droid, Movie]);
+ * console.log(pattern); // "Droid.@*FieldNames;Movie.@*FieldNames;"
+ *
+ * // Configuring all fields except those specified in the exclusion list of FieldNames for a specific GraphQL Type
+ * const pattern = FieldNamePattern.forAllFieldNamesExcludeFieldNamesOfTypeName([
+ *   [Droid, [id, name, friends]], // individual
+ *   [Human, [id, name, title]], // individual
+ *   [Starship, [name, length]], // individual
+ * ]);
+ * console.log(pattern); // "Droid.@*FieldNames-[id,name,friends];Human.@*FieldNames-[id,name,title];Starship.@*FieldNames-[name,length];"
+ *
+ * // Configuring specific fields of all Graphql Types
+ * const pattern = FieldNamePattern.forFieldNamesOfAllTypeNames([id, name, friends]);
+ * console.log(pattern); // "@*TypeNames.[id,name,friends];"
+ *
+ * // Configuring all fields of all Graphql Types
+ * const pattern = FieldNamePattern.forAllFieldNamesOfAllTypeNames();
+ * console.log(pattern); // "@*TypeNames.@*FieldNames;"
+ *
+ * // Configuring all fields except those specified in the exclusion list of FieldNames for all GraphQL Types
+ * const pattern = FieldNamePattern.forAllFieldNamesExcludeFieldNamesOfAllTypeNames([id, name, friends]);
+ * console.log(pattern); // "@*TypeNames.@*FieldNames-[id,name,friends];"
+ *
+ * // Configuring specific fields of all GraphQL Types except those specified in the exclusion list of TypeNames
+ * const pattern = FieldNamePattern.forFieldNamesOfAllTypeNamesExcludeTypeNames([Droid, Human], [id, name, friends]);
+ * console.log(pattern); // "@*TypeNames-[Droid,Human].[id,name,friends];"
+ *
+ * // Configuring all fields of all GraphQL Types except those specified in the exclusion list of TypeNames
+ * const pattern = FieldNamePattern.forAllFieldNamesOfAllTypeNamesExcludeTypeNames([Droid, Human]);
+ * console.log(pattern); // "@*TypeNames-[Droid,Human].@*FieldNames;"
+ *
+ * // Configuring all fields except those specified in the exclusion list of FieldNames of all GraphQL Types except those specified in the exclusion list of TypeNames
+ * const pattern = FieldNamePattern.forAllFieldNamesExcludeFieldNamesOfAllTypeNamesExcludeTypeNames(
+ *   [Droid, Human],
+ *   [id, name, friends]
+ * );
+ * console.log(pattern); // "@*TypeNames-[Droid,Human].@*FieldNames-[id,name,friends];"
+ * ```
+ *
+ */
+export class FieldNamePattern extends Pattern {
+    constructor(value) {
+        super(value);
+    }
+}
+//#region `'TypeName.[fieldNames];'`
+FieldNamePattern.forFieldNamesOfTypeName = (data) => {
+    const expandedPattern = {};
+    if (data.length < 1) {
+        throw new Error('Pattern cannot be created... an empty array was passed as parameter');
+    }
+    data.forEach(([typeNames, fieldNames]) => {
+        const _typeNames = arrayWrap(typeNames);
+        const _fieldNames = arrayWrap(fieldNames);
+        if (_typeNames.length < 1) {
+            throw new Error('Pattern cannot be created... No TypeNames were specified');
+        }
+        else if (_fieldNames.length < 1) {
+            throw new Error('Pattern cannot be created... No FieldNames were specified');
+        }
+        _typeNames.forEach(typeName => {
+            var _a;
+            expandedPattern[typeName.value] = [...((_a = expandedPattern[typeName.value]) !== null && _a !== void 0 ? _a : []), ..._fieldNames];
+        });
+    });
+    return FieldNamePattern.fromString(Object.keys(expandedPattern)
+        .map(_typeName => {
+        const _fieldNames = expandedPattern[_typeName].map(fieldName => fieldName.value).join();
+        return `${_typeName}.[${_fieldNames}];`;
+    })
+        .join(''));
+};
+FieldNamePattern.regexpForFieldNamesOfTypeName = /(?<typeName>\w+\s*)(?<!\s*@\s*\*\s*TypeNames\s*)\.\[\s*(?<fieldNames>(\w+,?\s*)*)\];/gim;
+FieldNamePattern.matchAndConfigureFieldNamesOfTypeName = (pattern, typeName, fieldName) => {
+    const regexp = FieldNamePattern.regexpForFieldNamesOfTypeName;
+    resetIndex(regexp);
+    let result;
+    const matchAndConfigure = {};
+    // typeName and fieldNames that were specified in the pattern
+    while ((result = regexp.exec(pattern.value)) !== null) {
+        const _typeName = result.groups.typeName;
+        const _fieldNames = strToList(result.groups.fieldNames);
+        _fieldNames.forEach(_fieldName => {
+            const key = `${_typeName}.${_fieldName}`;
+            const matchFound = true;
+            const shouldBeConfigured = true;
+            matchAndConfigure[key] = { matchFound, shouldBeConfigured };
+        });
+    }
+    resetIndex(regexp);
+    return matchAndConfigure;
+};
+//#endregion
+//#region `'TypeName.@*FieldNames;'`
+FieldNamePattern.forAllFieldNamesOfTypeName = (typeNames) => {
+    const _typeNames = arrayWrap(typeNames);
+    if (_typeNames.length < 1) {
+        throw new Error('Pattern cannot be created... No TypeNames were specified');
+    }
+    return FieldNamePattern.fromString(_typeNames.map(_typeName => `${_typeName.value}.${FieldName.allFieldNames};`).join(''));
+};
+FieldNamePattern.regexpForAllFieldNamesOfTypeName = /(?<typeName>\w+\s*)(?<!\s*@\s*\*\s*TypeNames\s*)\.@\*FieldNames;/gim;
+FieldNamePattern.matchAndConfigureAllFieldNamesOfTypeName = (pattern, typeName, fieldName) => {
+    const regexp = FieldNamePattern.regexpForAllFieldNamesOfTypeName;
+    resetIndex(regexp);
+    let result;
+    const matchAndConfigure = {};
+    while ((result = regexp.exec(pattern.value)) !== null) {
+        const _typeName = result.groups.typeName;
+        const key = `${_typeName}.${fieldName.value}`;
+        const matchFound = true;
+        const shouldBeConfigured = true;
+        matchAndConfigure[key] = { matchFound, shouldBeConfigured };
+    }
+    resetIndex(regexp);
+    return matchAndConfigure;
+};
+//#endregion
+//#region `'TypeName.@*FieldNames-[excludeFieldNames];'`
+FieldNamePattern.forAllFieldNamesExcludeFieldNamesOfTypeName = (data) => {
+    const expandedPattern = {};
+    if (data.length < 1) {
+        throw new Error('Pattern cannot be created... an empty array was passed as parameter');
+    }
+    data.forEach(([typeNames, fieldNames]) => {
+        const _typeNames = arrayWrap(typeNames);
+        const _fieldNames = arrayWrap(fieldNames);
+        if (_typeNames.length < 1) {
+            throw new Error('Pattern cannot be created... No TypeNames were specified');
+        }
+        else if (_fieldNames.length < 1) {
+            throw new Error('Pattern cannot be created... No FieldNames were specified');
+        }
+        _typeNames.forEach(typeName => {
+            var _a;
+            expandedPattern[typeName.value] = [...((_a = expandedPattern[typeName.value]) !== null && _a !== void 0 ? _a : []), ..._fieldNames];
+        });
+    });
+    return FieldNamePattern.fromString(Object.keys(expandedPattern)
+        .map(_typeName => {
+        const _fieldNames = expandedPattern[_typeName].map(fieldName => fieldName.value).join();
+        return `${_typeName}.${FieldName.allFieldNames}-[${_fieldNames}];`;
+    })
+        .join(''));
+};
+FieldNamePattern.regexpForAllFieldNamesExcludeFieldNamesOfTypeName = /(?<typeName>\w+\s*)(?<!\s*@\s*\*\s*TypeNames\s*)\.@\*FieldNames-\[\s*(?<fieldNames>(\w+,?\s*)*)\];/gim;
+FieldNamePattern.matchAndConfigureAllFieldNamesExcludeFieldNamesOfTypeName = (pattern, typeName, fieldName) => {
+    const regexp = FieldNamePattern.regexpForAllFieldNamesExcludeFieldNamesOfTypeName;
+    resetIndex(regexp);
+    let result;
+    const matchAndConfigure = {};
+    // typeName.fieldName that was excluded...
+    while ((result = regexp.exec(pattern.value)) !== null) {
+        const _typeName = result.groups.typeName;
+        const _fieldNames = strToList(result.groups.fieldNames);
+        _fieldNames.forEach(_fieldName => {
+            const key = `${_typeName}.${_fieldName}`;
+            const matchFound = true;
+            const shouldBeConfigured = false;
+            matchAndConfigure[key] = { matchFound, shouldBeConfigured };
+        });
+        // interpret global pattern: typeName.fieldName that was included
+        const key = `${_typeName}.${fieldName.value}`;
+        if (matchAndConfigure[key] === undefined) {
+            matchAndConfigure[key] = { matchFound: false, shouldBeConfigured: true };
+        }
+    }
+    resetIndex(regexp);
+    return matchAndConfigure;
+};
+//#endregion
+//#region `'@*TypeNames.[fieldNames];'`
+FieldNamePattern.forFieldNamesOfAllTypeNames = (fieldNames) => {
+    fieldNames = arrayWrap(fieldNames);
+    if (fieldNames.length < 1) {
+        throw new Error('Pattern cannot be created... No FieldNames were specified');
+    }
+    const _fieldNames = fieldNames.map(fieldName => fieldName.value).join();
+    return FieldNamePattern.fromString(`${TypeName.allTypeNames}.[${_fieldNames}];`);
+};
+FieldNamePattern.regexpForFieldNamesOfAllTypeNames = /@\*TypeNames\.\[\s*(?<fieldNames>(\w+,?\s*)*)\];/gim;
+FieldNamePattern.matchAndConfigureFieldNamesOfAllTypeNames = (pattern, typeName, fieldName) => {
+    const regexp = FieldNamePattern.regexpForFieldNamesOfAllTypeNames;
+    resetIndex(regexp);
+    let result;
+    const matchAndConfigure = {};
+    while ((result = regexp.exec(pattern.value)) !== null) {
+        const _fieldNames = strToList(result.groups.fieldNames);
+        _fieldNames.forEach(_fieldName => {
+            const key = `${typeName.value}.${_fieldName}`;
+            const matchFound = true;
+            const shouldBeConfigured = true;
+            matchAndConfigure[key] = { matchFound, shouldBeConfigured };
+        });
+    }
+    resetIndex(regexp);
+    return matchAndConfigure;
+};
+//#endregion
+//#region `'@*TypeNames.@*FieldNames;'`
+FieldNamePattern.forAllFieldNamesOfAllTypeNames = () => {
+    return FieldNamePattern.fromString(`${TypeName.allTypeNames}.${FieldName.allFieldNames};`);
+};
+FieldNamePattern.regexpForAllFieldNamesOfAllTypeNames = /@\*TypeNames\.@\*FieldNames;/gim;
+FieldNamePattern.matchAndConfigureAllFieldNamesOfAllTypeNames = (pattern, typeName, fieldName) => {
+    const regexp = FieldNamePattern.regexpForAllFieldNamesOfAllTypeNames;
+    resetIndex(regexp);
+    const matchAndConfigure = {};
+    const key = `${typeName.value}.${fieldName.value}`;
+    const matchFound = regexp.test(pattern.value);
+    const shouldBeConfigured = matchFound;
+    matchAndConfigure[key] = { matchFound, shouldBeConfigured };
+    resetIndex(regexp);
+    return matchAndConfigure;
+};
+//#endregion
+//#region `'@*TypeNames.@*FieldNames-[excludeFieldNames];'`
+FieldNamePattern.forAllFieldNamesExcludeFieldNamesOfAllTypeNames = (fieldNames) => {
+    fieldNames = arrayWrap(fieldNames);
+    if (fieldNames.length < 1) {
+        throw new Error('Pattern cannot be created... No FieldNames were excluded');
+    }
+    const _fieldNames = fieldNames.map(fieldName => fieldName.value).join();
+    return FieldNamePattern.fromString(`${TypeName.allTypeNames}.${FieldName.allFieldNames}-[${_fieldNames}];`);
+};
+FieldNamePattern.regexpForAllFieldNamesExcludeFieldNamesOfAllTypeNames = /@\*TypeNames\.@\*FieldNames-\[\s*(?<fieldNames>(\w+,?\s*)*)\];/gim;
+FieldNamePattern.matchAndConfigureAllFieldNamesExcludeFieldNamesOfAllTypeNames = (pattern, typeName, fieldName) => {
+    const regexp = FieldNamePattern.regexpForAllFieldNamesExcludeFieldNamesOfAllTypeNames;
+    resetIndex(regexp);
+    let result;
+    const matchAndConfigure = {};
+    while ((result = regexp.exec(pattern.value)) !== null) {
+        const _fieldNames = strToList(result.groups.fieldNames);
+        // typeName.fieldName that was excluded...
+        _fieldNames.forEach(_fieldName => {
+            const key = `${typeName.value}.${_fieldName}`;
+            const matchFound = true;
+            const shouldBeConfigured = false;
+            matchAndConfigure[key] = { matchFound, shouldBeConfigured };
+        });
+    }
+    // interpret global pattern: typeName.fieldName that was included...
+    const key = `${typeName.value}.${fieldName.value}`;
+    if (matchAndConfigure[key] === undefined) {
+        matchAndConfigure[key] = { matchFound: false, shouldBeConfigured: true };
+    }
+    resetIndex(regexp);
+    return matchAndConfigure;
+};
+//#endregion
+//#region `'@*TypeNames-[excludeTypeNames].[fieldNames];'`
+FieldNamePattern.forFieldNamesOfAllTypeNamesExcludeTypeNames = (typeNames, fieldNames) => {
+    typeNames = arrayWrap(typeNames);
+    fieldNames = arrayWrap(fieldNames);
+    if (typeNames.length < 1) {
+        throw new Error('Pattern cannot be created... No TypeNames were excluded');
+    }
+    else if (fieldNames.length < 1) {
+        throw new Error('Pattern cannot be created... No FieldNames were specified');
+    }
+    const _typeNames = typeNames.map(typeName => typeName.value).join();
+    const _fieldNames = fieldNames.map(fieldName => fieldName.value).join();
+    return FieldNamePattern.fromString(`${TypeName.allTypeNames}-[${_typeNames}].[${_fieldNames}];`);
+};
+FieldNamePattern.regexpForFieldNamesOfAllTypeNamesExcludeTypeNames = /@\*TypeNames-\[\s*(?<typeNames>(\w+,?\s*)*)\]\.\[\s*(?<fieldNames>(\w+,?\s*)*)\];/gim;
+FieldNamePattern.matchAndConfigureFieldNamesOfAllTypeNamesExcludeTypeNames = (pattern, typeName, fieldName) => {
+    const regexp = FieldNamePattern.regexpForFieldNamesOfAllTypeNamesExcludeTypeNames;
+    resetIndex(regexp);
+    let result;
+    const matchAndConfigure = {};
+    while ((result = regexp.exec(pattern.value)) !== null) {
+        const _typeNames = strToList(result.groups.typeNames);
+        const _fieldNames = strToList(result.groups.fieldNames);
+        // typeName.fieldName that was excluded
+        _typeNames.forEach(_typeName => _fieldNames.forEach(_fieldName => {
+            const key = `${_typeName}.${_fieldName}`;
+            const matchFound = true;
+            const shouldBeConfigured = false;
+            matchAndConfigure[key] = { matchFound, shouldBeConfigured };
+        }));
+        // interpret the global pattern:
+        // for fieldNames specified in the list of fieldNames for other typeNames not specified in the exclusion list of TypeNames
+        _fieldNames.forEach(_fieldName => {
+            const key = `${typeName.value}.${_fieldName}`;
+            if (!_typeNames.includes(typeName.value) && matchAndConfigure[key] === undefined) {
+                const matchFound = false;
+                const shouldBeConfigured = true;
+                matchAndConfigure[key] = { matchFound, shouldBeConfigured };
+            }
+        });
+    }
+    resetIndex(regexp);
+    return matchAndConfigure;
+};
+//#endregion
+//#region `'@*TypeNames-[excludeTypeNames].@*FieldNames;'`
+FieldNamePattern.forAllFieldNamesOfAllTypeNamesExcludeTypeNames = (typeNames) => {
+    typeNames = arrayWrap(typeNames);
+    if (typeNames.length < 1) {
+        throw new Error('Pattern cannot be created... No TypeNames were excluded');
+    }
+    const _typeNames = typeNames.map(typeName => typeName.value).join();
+    return FieldNamePattern.fromString(`${TypeName.allTypeNames}-[${_typeNames}].${FieldName.allFieldNames};`);
+};
+FieldNamePattern.regexpForAllFieldNamesOfAllTypeNamesExcludeTypeNames = /@\*TypeNames-\[\s*(?<typeNames>(\w+,?\s*)*)\]\.@\*FieldNames;/gim;
+FieldNamePattern.matchAndConfigureAllFieldNamesOfAllTypeNamesExcludeTypeNames = (pattern, typeName, fieldName) => {
+    const regexp = FieldNamePattern.regexpForAllFieldNamesOfAllTypeNamesExcludeTypeNames;
+    resetIndex(regexp);
+    let result;
+    const matchAndConfigure = {};
+    while ((result = regexp.exec(pattern.value)) !== null) {
+        const _typeNames = strToList(result.groups.typeNames);
+        _typeNames.forEach(_typeName => {
+            const key = `${_typeName}.${fieldName.value}`;
+            const matchFound = true;
+            const shouldBeConfigured = false;
+            matchAndConfigure[key] = { matchFound, shouldBeConfigured };
+        });
+        // interpret the global pattern:
+        // for all other typeName.fieldName combination where the typeName is not in the exclusion list of TypeNames
+        const key = `${typeName.value}.${fieldName.value}`;
+        if (matchAndConfigure[key] === undefined) {
+            matchAndConfigure[key] = { matchFound: false, shouldBeConfigured: true };
+        }
+    }
+    resetIndex(regexp);
+    return matchAndConfigure;
+};
+//#endregion
+//#region `'@*TypeNames-[excludeTypeNames].@*FieldNames-[excludeFieldNames];'`
+FieldNamePattern.forAllFieldNamesExcludeFieldNamesOfAllTypeNamesExcludeTypeNames = (typeNames, fieldNames) => {
+    typeNames = arrayWrap(typeNames);
+    fieldNames = arrayWrap(fieldNames);
+    if (typeNames.length < 1) {
+        throw new Error('Pattern cannot be created... No TypeNames were excluded');
+    }
+    else if (fieldNames.length < 1) {
+        throw new Error('Pattern cannot be created... No FieldNames were excluded');
+    }
+    const _typeNames = typeNames.map(typeName => typeName.value).join();
+    const _fieldNames = fieldNames.map(fieldName => fieldName.value).join();
+    return FieldNamePattern.fromString(`${TypeName.allTypeNames}-[${_typeNames}].${FieldName.allFieldNames}-[${_fieldNames}];`);
+};
+FieldNamePattern.regexpForAllFieldNamesExcludeFieldNamesOfAllTypeNamesExcludeTypeNames = /@\*TypeNames-\[\s*(?<typeNames>(\w+,?\s*)*)\]\.@\*FieldNames-\[\s*(?<fieldNames>(\w+,?\s*)*)\];/gim;
+FieldNamePattern.matchAndConfigureAllFieldNamesExcludeFieldNamesOfAllTypeNamesExcludeTypeNames = (pattern, typeName, fieldName) => {
+    const regexp = FieldNamePattern.regexpForAllFieldNamesExcludeFieldNamesOfAllTypeNamesExcludeTypeNames;
+    resetIndex(regexp);
+    let result;
+    const matchAndConfigure = {};
+    while ((result = regexp.exec(pattern.value)) !== null) {
+        const _typeNames = strToList(result.groups.typeNames);
+        const _fieldNames = strToList(result.groups.fieldNames);
+        _typeNames.forEach(_typeName => _fieldNames.forEach(_fieldName => {
+            const key = `${_typeName}.${_fieldName}`;
+            const matchFound = true;
+            const shouldBeConfigured = false;
+            matchAndConfigure[key] = { matchFound, shouldBeConfigured };
+        }));
+    }
+    // interpret the global pattern
+    // for any other typeName.fieldName combination which is not excluded in the pattern
+    const key = `${typeName.value}.${fieldName.value}`;
+    if (matchAndConfigure[key] === undefined) {
+        matchAndConfigure[key] = { matchFound: false, shouldBeConfigured: true };
+    }
+    resetIndex(regexp);
+    return matchAndConfigure;
+};
+// type MatchAndConfigure =
+//   | 'matchAndConfigureTypeNames'
+//   | 'matchAndConfigureAllTypeNames'
+//   | 'matchAndConfigureAllTypeNamesExcludeTypeNames'
+//   | 'matchAndConfigureFieldNamesOfTypeName'
+//   | 'matchAndConfigureAllFieldNamesOfTypeName'
+//   | 'matchAndConfigureAllFieldNamesExcludeFieldNamesOfTypeName'
+//   | 'matchAndConfigureFieldNamesOfAllTypeNames'
+//   | 'matchAndConfigureAllFieldNamesOfAllTypeNames'
+//   | 'matchAndConfigureAllFieldNamesExcludeFieldNamesOfAllTypeNames'
+//   | 'matchAndConfigureFieldNamesOfAllTypeNamesExcludeTypeNames'
+//   | 'matchAndConfigureAllFieldNamesOfAllTypeNamesExcludeTypeNames'
+//   | 'matchAndConfigureAllFieldNamesExcludeFieldNamesOfAllTypeNamesExcludeTypeNames';