feat(utils/pattern): add method to split pattern into segments

Author: mrmlnc

src/tests/index.ts

@@ -1,9 +1,11 @@
 import * as entry from './utils/entry';
 import * as errno from './utils/errno';
+import * as pattern from './utils/pattern';
 import * as task from './utils/task';
 
 export {
 	entry,
 	errno,
+	pattern,
 	task
 };

src/tests/utils/pattern.ts

@@ -0,0 +1,36 @@
+import { PatternSegment, Pattern, MicromatchOptions } from '../../types';
+import * as utils from '../../utils';
+
+class PatternSegmentBuilder {
+	private readonly _segment: PatternSegment = {
+		dynamic: false,
+		pattern: ''
+	};
+
+	public dynamic(): this {
+		this._segment.dynamic = true;
+
+		return this;
+	}
+
+	public pattern(pattern: Pattern): this {
+		this._segment.pattern = pattern;
+
+		return this;
+	}
+
+	public build(options: MicromatchOptions = {}): PatternSegment {
+		if (!this._segment.dynamic) {
+			return this._segment;
+		}
+
+		return {
+			...this._segment,
+			patternRe: utils.pattern.makeRe(this._segment.pattern, options)
+		};
+	}
+}
+
+export function segment(): PatternSegmentBuilder {
+	return new PatternSegmentBuilder();
+}

src/types/index.ts

@@ -9,6 +9,19 @@ export type Pattern = string;
 export type PatternRe = RegExp;
 export type PatternsGroup = Record<string, Pattern[]>;
 
+export type PatternSegment = StaticPatternSegment | DynamicPatternSegment;
+
+export type StaticPatternSegment = {
+	dynamic: false;
+	pattern: Pattern;
+};
+
+export type DynamicPatternSegment = {
+	dynamic: true;
+	pattern: Pattern;
+	patternRe: PatternRe;
+};
+
 export type ReaderOptions = fsWalk.Options & {
 	transform(entry: Entry): EntryItem;
 	deepFilter: DeepFilterFunction;

src/utils/pattern.spec.ts

@@ -1,6 +1,7 @@
 import * as assert from 'assert';
 
-import { Pattern } from '../types';
+import { Pattern, PatternSegment } from '../types';
+import * as tests from '../tests';
 import * as util from './pattern';
 
 describe('Utils → Pattern', () => {
@@ -385,6 +386,22 @@ describe('Utils → Pattern', () => {
 		});
 	});
 
+	describe('.getPatternSegments', () => {
+		it('should return an array of pattern segments', () => {
+			const expected: PatternSegment[] = [
+				tests.pattern.segment().pattern('a').build(),
+				tests.pattern.segment().dynamic().pattern('*').build(),
+				tests.pattern.segment().pattern('b').build(),
+				tests.pattern.segment().dynamic().pattern('**').build(),
+				tests.pattern.segment().pattern('c').build()
+			];
+
+			const actual = util.getPatternSegments('a/*/b/**/c', {});
+
+			assert.deepStrictEqual(actual, expected);
+		});
+	});
+
 	describe('.makeRe', () => {
 		it('should return regexp for provided pattern', () => {
 			const actual = util.makeRe('*.js', {});

src/utils/pattern.ts

@@ -3,7 +3,7 @@ import * as path from 'path';
 import * as globParent from 'glob-parent';
 import * as micromatch from 'micromatch';
 
-import { MicromatchOptions, Pattern, PatternRe } from '../types';
+import { MicromatchOptions, Pattern, PatternRe, PatternSegment } from '../types';
 
 const GLOBSTAR = '**';
 const ESCAPE_SYMBOL = '\\';
@@ -143,6 +143,27 @@ export function getPatternParts(pattern: Pattern, options: MicromatchOptions): P
 	return info.parts;
 }
 
+export function getPatternSegments(pattern: Pattern, options: MicromatchOptions): PatternSegment[] {
+	const parts = getPatternParts(pattern, options);
+
+	return parts.map((part) => {
+		const dynamic = isDynamicPattern(part);
+
+		if (!dynamic) {
+			return {
+				dynamic: false,
+				pattern: part
+			};
+		}
+
+		return {
+			dynamic: true,
+			pattern: part,
+			patternRe: makeRe(part, options)
+		};
+	});
+}
+
 export function makeRe(pattern: Pattern, options: MicromatchOptions): PatternRe {
 	return micromatch.makeRe(pattern, options);
 }