projen 0.99.0 → 0.99.2

package/node_modules/fast-glob/out/providers/filters/entry.js

@@ -1,85 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils = require("../../utils");
-class EntryFilter {
-    constructor(_settings, _micromatchOptions) {
-        this._settings = _settings;
-        this._micromatchOptions = _micromatchOptions;
-        this.index = new Map();
-    }
-    getFilter(positive, negative) {
-        const [absoluteNegative, relativeNegative] = utils.pattern.partitionAbsoluteAndRelative(negative);
-        const patterns = {
-            positive: {
-                all: utils.pattern.convertPatternsToRe(positive, this._micromatchOptions)
-            },
-            negative: {
-                absolute: utils.pattern.convertPatternsToRe(absoluteNegative, Object.assign(Object.assign({}, this._micromatchOptions), { dot: true })),
-                relative: utils.pattern.convertPatternsToRe(relativeNegative, Object.assign(Object.assign({}, this._micromatchOptions), { dot: true }))
-            }
-        };
-        return (entry) => this._filter(entry, patterns);
-    }
-    _filter(entry, patterns) {
-        const filepath = utils.path.removeLeadingDotSegment(entry.path);
-        if (this._settings.unique && this._isDuplicateEntry(filepath)) {
-            return false;
-        }
-        if (this._onlyFileFilter(entry) || this._onlyDirectoryFilter(entry)) {
-            return false;
-        }
-        const isMatched = this._isMatchToPatternsSet(filepath, patterns, entry.dirent.isDirectory());
-        if (this._settings.unique && isMatched) {
-            this._createIndexRecord(filepath);
-        }
-        return isMatched;
-    }
-    _isDuplicateEntry(filepath) {
-        return this.index.has(filepath);
-    }
-    _createIndexRecord(filepath) {
-        this.index.set(filepath, undefined);
-    }
-    _onlyFileFilter(entry) {
-        return this._settings.onlyFiles && !entry.dirent.isFile();
-    }
-    _onlyDirectoryFilter(entry) {
-        return this._settings.onlyDirectories && !entry.dirent.isDirectory();
-    }
-    _isMatchToPatternsSet(filepath, patterns, isDirectory) {
-        const isMatched = this._isMatchToPatterns(filepath, patterns.positive.all, isDirectory);
-        if (!isMatched) {
-            return false;
-        }
-        const isMatchedByRelativeNegative = this._isMatchToPatterns(filepath, patterns.negative.relative, isDirectory);
-        if (isMatchedByRelativeNegative) {
-            return false;
-        }
-        const isMatchedByAbsoluteNegative = this._isMatchToAbsoluteNegative(filepath, patterns.negative.absolute, isDirectory);
-        if (isMatchedByAbsoluteNegative) {
-            return false;
-        }
-        return true;
-    }
-    _isMatchToAbsoluteNegative(filepath, patternsRe, isDirectory) {
-        if (patternsRe.length === 0) {
-            return false;
-        }
-        const fullpath = utils.path.makeAbsolute(this._settings.cwd, filepath);
-        return this._isMatchToPatterns(fullpath, patternsRe, isDirectory);
-    }
-    _isMatchToPatterns(filepath, patternsRe, isDirectory) {
-        if (patternsRe.length === 0) {
-            return false;
-        }
-        // Trying to match files and directories by patterns.
-        const isMatched = utils.pattern.matchAny(filepath, patternsRe);
-        // A pattern with a trailling slash can be used for directory matching.
-        // To apply such pattern, we need to add a tralling slash to the path.
-        if (!isMatched && isDirectory) {
-            return utils.pattern.matchAny(filepath + '/', patternsRe);
-        }
-        return isMatched;
-    }
-}
-exports.default = EntryFilter;

package/node_modules/fast-glob/out/providers/filters/error.d.ts

@@ -1,8 +0,0 @@
-import Settings from '../../settings';
-import { ErrorFilterFunction } from '../../types';
-export default class ErrorFilter {
-    private readonly _settings;
-    constructor(_settings: Settings);
-    getFilter(): ErrorFilterFunction;
-    private _isNonFatalError;
-}

package/node_modules/fast-glob/out/providers/filters/error.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils = require("../../utils");
-class ErrorFilter {
-    constructor(_settings) {
-        this._settings = _settings;
-    }
-    getFilter() {
-        return (error) => this._isNonFatalError(error);
-    }
-    _isNonFatalError(error) {
-        return utils.errno.isEnoentCodeError(error) || this._settings.suppressErrors;
-    }
-}
-exports.default = ErrorFilter;

package/node_modules/fast-glob/out/providers/matchers/matcher.d.ts

@@ -1,33 +0,0 @@
-import { Pattern, MicromatchOptions, PatternRe } from '../../types';
-import Settings from '../../settings';
-export type PatternSegment = StaticPatternSegment | DynamicPatternSegment;
-type StaticPatternSegment = {
-    dynamic: false;
-    pattern: Pattern;
-};
-type DynamicPatternSegment = {
-    dynamic: true;
-    pattern: Pattern;
-    patternRe: PatternRe;
-};
-export type PatternSection = PatternSegment[];
-export type PatternInfo = {
-    /**
-     * Indicates that the pattern has a globstar (more than a single section).
-     */
-    complete: boolean;
-    pattern: Pattern;
-    segments: PatternSegment[];
-    sections: PatternSection[];
-};
-export default abstract class Matcher {
-    private readonly _patterns;
-    private readonly _settings;
-    private readonly _micromatchOptions;
-    protected readonly _storage: PatternInfo[];
-    constructor(_patterns: Pattern[], _settings: Settings, _micromatchOptions: MicromatchOptions);
-    private _fillStorage;
-    private _getPatternSegments;
-    private _splitSegmentsIntoSections;
-}
-export {};

package/node_modules/fast-glob/out/providers/matchers/matcher.js

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils = require("../../utils");
-class Matcher {
-    constructor(_patterns, _settings, _micromatchOptions) {
-        this._patterns = _patterns;
-        this._settings = _settings;
-        this._micromatchOptions = _micromatchOptions;
-        this._storage = [];
-        this._fillStorage();
-    }
-    _fillStorage() {
-        for (const pattern of this._patterns) {
-            const segments = this._getPatternSegments(pattern);
-            const sections = this._splitSegmentsIntoSections(segments);
-            this._storage.push({
-                complete: sections.length <= 1,
-                pattern,
-                segments,
-                sections
-            });
-        }
-    }
-    _getPatternSegments(pattern) {
-        const parts = utils.pattern.getPatternParts(pattern, this._micromatchOptions);
-        return parts.map((part) => {
-            const dynamic = utils.pattern.isDynamicPattern(part, this._settings);
-            if (!dynamic) {
-                return {
-                    dynamic: false,
-                    pattern: part
-                };
-            }
-            return {
-                dynamic: true,
-                pattern: part,
-                patternRe: utils.pattern.makeRe(part, this._micromatchOptions)
-            };
-        });
-    }
-    _splitSegmentsIntoSections(segments) {
-        return utils.array.splitWhen(segments, (segment) => segment.dynamic && utils.pattern.hasGlobStar(segment.pattern));
-    }
-}
-exports.default = Matcher;

package/node_modules/fast-glob/out/providers/matchers/partial.d.ts

@@ -1,4 +0,0 @@
-import Matcher from './matcher';
-export default class PartialMatcher extends Matcher {
-    match(filepath: string): boolean;
-}

package/node_modules/fast-glob/out/providers/matchers/partial.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const matcher_1 = require("./matcher");
-class PartialMatcher extends matcher_1.default {
-    match(filepath) {
-        const parts = filepath.split('/');
-        const levels = parts.length;
-        const patterns = this._storage.filter((info) => !info.complete || info.segments.length > levels);
-        for (const pattern of patterns) {
-            const section = pattern.sections[0];
-            /**
-             * In this case, the pattern has a globstar and we must read all directories unconditionally,
-             * but only if the level has reached the end of the first group.
-             *
-             * fixtures/{a,b}/**
-             *  ^ true/false  ^ always true
-            */
-            if (!pattern.complete && levels > section.length) {
-                return true;
-            }
-            const match = parts.every((part, index) => {
-                const segment = pattern.segments[index];
-                if (segment.dynamic && segment.patternRe.test(part)) {
-                    return true;
-                }
-                if (!segment.dynamic && segment.pattern === part) {
-                    return true;
-                }
-                return false;
-            });
-            if (match) {
-                return true;
-            }
-        }
-        return false;
-    }
-}
-exports.default = PartialMatcher;

package/node_modules/fast-glob/out/providers/provider.d.ts

@@ -1,19 +0,0 @@
-import { Task } from '../managers/tasks';
-import Settings from '../settings';
-import { MicromatchOptions, ReaderOptions } from '../types';
-import DeepFilter from './filters/deep';
-import EntryFilter from './filters/entry';
-import ErrorFilter from './filters/error';
-import EntryTransformer from './transformers/entry';
-export default abstract class Provider<T> {
-    protected readonly _settings: Settings;
-    readonly errorFilter: ErrorFilter;
-    readonly entryFilter: EntryFilter;
-    readonly deepFilter: DeepFilter;
-    readonly entryTransformer: EntryTransformer;
-    constructor(_settings: Settings);
-    abstract read(_task: Task): T;
-    protected _getRootDirectory(task: Task): string;
-    protected _getReaderOptions(task: Task): ReaderOptions;
-    protected _getMicromatchOptions(): MicromatchOptions;
-}

package/node_modules/fast-glob/out/providers/provider.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const path = require("path");
-const deep_1 = require("./filters/deep");
-const entry_1 = require("./filters/entry");
-const error_1 = require("./filters/error");
-const entry_2 = require("./transformers/entry");
-class Provider {
-    constructor(_settings) {
-        this._settings = _settings;
-        this.errorFilter = new error_1.default(this._settings);
-        this.entryFilter = new entry_1.default(this._settings, this._getMicromatchOptions());
-        this.deepFilter = new deep_1.default(this._settings, this._getMicromatchOptions());
-        this.entryTransformer = new entry_2.default(this._settings);
-    }
-    _getRootDirectory(task) {
-        return path.resolve(this._settings.cwd, task.base);
-    }
-    _getReaderOptions(task) {
-        const basePath = task.base === '.' ? '' : task.base;
-        return {
-            basePath,
-            pathSegmentSeparator: '/',
-            concurrency: this._settings.concurrency,
-            deepFilter: this.deepFilter.getFilter(basePath, task.positive, task.negative),
-            entryFilter: this.entryFilter.getFilter(task.positive, task.negative),
-            errorFilter: this.errorFilter.getFilter(),
-            followSymbolicLinks: this._settings.followSymbolicLinks,
-            fs: this._settings.fs,
-            stats: this._settings.stats,
-            throwErrorOnBrokenSymbolicLink: this._settings.throwErrorOnBrokenSymbolicLink,
-            transform: this.entryTransformer.getTransformer()
-        };
-    }
-    _getMicromatchOptions() {
-        return {
-            dot: this._settings.dot,
-            matchBase: this._settings.baseNameMatch,
-            nobrace: !this._settings.braceExpansion,
-            nocase: !this._settings.caseSensitiveMatch,
-            noext: !this._settings.extglob,
-            noglobstar: !this._settings.globstar,
-            posix: true,
-            strictSlashes: false
-        };
-    }
-}
-exports.default = Provider;

package/node_modules/fast-glob/out/providers/stream.d.ts

@@ -1,11 +0,0 @@
-/// <reference types="node" />
-import { Readable } from 'stream';
-import { Task } from '../managers/tasks';
-import ReaderStream from '../readers/stream';
-import { ReaderOptions } from '../types';
-import Provider from './provider';
-export default class ProviderStream extends Provider<Readable> {
-    protected _reader: ReaderStream;
-    read(task: Task): Readable;
-    api(root: string, task: Task, options: ReaderOptions): Readable;
-}

package/node_modules/fast-glob/out/providers/stream.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const stream_1 = require("stream");
-const stream_2 = require("../readers/stream");
-const provider_1 = require("./provider");
-class ProviderStream extends provider_1.default {
-    constructor() {
-        super(...arguments);
-        this._reader = new stream_2.default(this._settings);
-    }
-    read(task) {
-        const root = this._getRootDirectory(task);
-        const options = this._getReaderOptions(task);
-        const source = this.api(root, task, options);
-        const destination = new stream_1.Readable({ objectMode: true, read: () => { } });
-        source
-            .once('error', (error) => destination.emit('error', error))
-            .on('data', (entry) => destination.emit('data', options.transform(entry)))
-            .once('end', () => destination.emit('end'));
-        destination
-            .once('close', () => source.destroy());
-        return destination;
-    }
-    api(root, task, options) {
-        if (task.dynamic) {
-            return this._reader.dynamic(root, options);
-        }
-        return this._reader.static(task.patterns, options);
-    }
-}
-exports.default = ProviderStream;

package/node_modules/fast-glob/out/providers/sync.d.ts

@@ -1,9 +0,0 @@
-import { Task } from '../managers/tasks';
-import ReaderSync from '../readers/sync';
-import { Entry, EntryItem, ReaderOptions } from '../types';
-import Provider from './provider';
-export default class ProviderSync extends Provider<EntryItem[]> {
-    protected _reader: ReaderSync;
-    read(task: Task): EntryItem[];
-    api(root: string, task: Task, options: ReaderOptions): Entry[];
-}

package/node_modules/fast-glob/out/providers/sync.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const sync_1 = require("../readers/sync");
-const provider_1 = require("./provider");
-class ProviderSync extends provider_1.default {
-    constructor() {
-        super(...arguments);
-        this._reader = new sync_1.default(this._settings);
-    }
-    read(task) {
-        const root = this._getRootDirectory(task);
-        const options = this._getReaderOptions(task);
-        const entries = this.api(root, task, options);
-        return entries.map(options.transform);
-    }
-    api(root, task, options) {
-        if (task.dynamic) {
-            return this._reader.dynamic(root, options);
-        }
-        return this._reader.static(task.patterns, options);
-    }
-}
-exports.default = ProviderSync;

package/node_modules/fast-glob/out/providers/transformers/entry.d.ts

@@ -1,8 +0,0 @@
-import Settings from '../../settings';
-import { EntryTransformerFunction } from '../../types';
-export default class EntryTransformer {
-    private readonly _settings;
-    constructor(_settings: Settings);
-    getTransformer(): EntryTransformerFunction;
-    private _transform;
-}

package/node_modules/fast-glob/out/providers/transformers/entry.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils = require("../../utils");
-class EntryTransformer {
-    constructor(_settings) {
-        this._settings = _settings;
-    }
-    getTransformer() {
-        return (entry) => this._transform(entry);
-    }
-    _transform(entry) {
-        let filepath = entry.path;
-        if (this._settings.absolute) {
-            filepath = utils.path.makeAbsolute(this._settings.cwd, filepath);
-            filepath = utils.path.unixify(filepath);
-        }
-        if (this._settings.markDirectories && entry.dirent.isDirectory()) {
-            filepath += '/';
-        }
-        if (!this._settings.objectMode) {
-            return filepath;
-        }
-        return Object.assign(Object.assign({}, entry), { path: filepath });
-    }
-}
-exports.default = EntryTransformer;

package/node_modules/fast-glob/out/readers/async.d.ts

@@ -1,10 +0,0 @@
-import * as fsWalk from '@nodelib/fs.walk';
-import { Entry, ReaderOptions, Pattern } from '../types';
-import Reader from './reader';
-import ReaderStream from './stream';
-export default class ReaderAsync extends Reader<Promise<Entry[]>> {
-    protected _walkAsync: typeof fsWalk.walk;
-    protected _readerStream: ReaderStream;
-    dynamic(root: string, options: ReaderOptions): Promise<Entry[]>;
-    static(patterns: Pattern[], options: ReaderOptions): Promise<Entry[]>;
-}

package/node_modules/fast-glob/out/readers/async.js

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const fsWalk = require("@nodelib/fs.walk");
-const reader_1 = require("./reader");
-const stream_1 = require("./stream");
-class ReaderAsync extends reader_1.default {
-    constructor() {
-        super(...arguments);
-        this._walkAsync = fsWalk.walk;
-        this._readerStream = new stream_1.default(this._settings);
-    }
-    dynamic(root, options) {
-        return new Promise((resolve, reject) => {
-            this._walkAsync(root, options, (error, entries) => {
-                if (error === null) {
-                    resolve(entries);
-                }
-                else {
-                    reject(error);
-                }
-            });
-        });
-    }
-    async static(patterns, options) {
-        const entries = [];
-        const stream = this._readerStream.static(patterns, options);
-        // After #235, replace it with an asynchronous iterator.
-        return new Promise((resolve, reject) => {
-            stream.once('error', reject);
-            stream.on('data', (entry) => entries.push(entry));
-            stream.once('end', () => resolve(entries));
-        });
-    }
-}
-exports.default = ReaderAsync;

package/node_modules/fast-glob/out/readers/reader.d.ts

@@ -1,15 +0,0 @@
-/// <reference types="node" />
-import * as fs from 'fs';
-import * as fsStat from '@nodelib/fs.stat';
-import Settings from '../settings';
-import { Entry, ErrnoException, Pattern, ReaderOptions } from '../types';
-export default abstract class Reader<T> {
-    protected readonly _settings: Settings;
-    protected readonly _fsStatSettings: fsStat.Settings;
-    constructor(_settings: Settings);
-    abstract dynamic(root: string, options: ReaderOptions): T;
-    abstract static(patterns: Pattern[], options: ReaderOptions): T;
-    protected _getFullEntryPath(filepath: string): string;
-    protected _makeEntry(stats: fs.Stats, pattern: Pattern): Entry;
-    protected _isFatalError(error: ErrnoException): boolean;
-}

package/node_modules/fast-glob/out/readers/reader.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const path = require("path");
-const fsStat = require("@nodelib/fs.stat");
-const utils = require("../utils");
-class Reader {
-    constructor(_settings) {
-        this._settings = _settings;
-        this._fsStatSettings = new fsStat.Settings({
-            followSymbolicLink: this._settings.followSymbolicLinks,
-            fs: this._settings.fs,
-            throwErrorOnBrokenSymbolicLink: this._settings.followSymbolicLinks
-        });
-    }
-    _getFullEntryPath(filepath) {
-        return path.resolve(this._settings.cwd, filepath);
-    }
-    _makeEntry(stats, pattern) {
-        const entry = {
-            name: pattern,
-            path: pattern,
-            dirent: utils.fs.createDirentFromStats(pattern, stats)
-        };
-        if (this._settings.stats) {
-            entry.stats = stats;
-        }
-        return entry;
-    }
-    _isFatalError(error) {
-        return !utils.errno.isEnoentCodeError(error) && !this._settings.suppressErrors;
-    }
-}
-exports.default = Reader;

package/node_modules/fast-glob/out/readers/stream.d.ts

@@ -1,14 +0,0 @@
-/// <reference types="node" />
-import { Readable } from 'stream';
-import * as fsStat from '@nodelib/fs.stat';
-import * as fsWalk from '@nodelib/fs.walk';
-import { Pattern, ReaderOptions } from '../types';
-import Reader from './reader';
-export default class ReaderStream extends Reader<Readable> {
-    protected _walkStream: typeof fsWalk.walkStream;
-    protected _stat: typeof fsStat.stat;
-    dynamic(root: string, options: ReaderOptions): Readable;
-    static(patterns: Pattern[], options: ReaderOptions): Readable;
-    private _getEntry;
-    private _getStat;
-}

package/node_modules/fast-glob/out/readers/stream.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const stream_1 = require("stream");
-const fsStat = require("@nodelib/fs.stat");
-const fsWalk = require("@nodelib/fs.walk");
-const reader_1 = require("./reader");
-class ReaderStream extends reader_1.default {
-    constructor() {
-        super(...arguments);
-        this._walkStream = fsWalk.walkStream;
-        this._stat = fsStat.stat;
-    }
-    dynamic(root, options) {
-        return this._walkStream(root, options);
-    }
-    static(patterns, options) {
-        const filepaths = patterns.map(this._getFullEntryPath, this);
-        const stream = new stream_1.PassThrough({ objectMode: true });
-        stream._write = (index, _enc, done) => {
-            return this._getEntry(filepaths[index], patterns[index], options)
-                .then((entry) => {
-                if (entry !== null && options.entryFilter(entry)) {
-                    stream.push(entry);
-                }
-                if (index === filepaths.length - 1) {
-                    stream.end();
-                }
-                done();
-            })
-                .catch(done);
-        };
-        for (let i = 0; i < filepaths.length; i++) {
-            stream.write(i);
-        }
-        return stream;
-    }
-    _getEntry(filepath, pattern, options) {
-        return this._getStat(filepath)
-            .then((stats) => this._makeEntry(stats, pattern))
-            .catch((error) => {
-            if (options.errorFilter(error)) {
-                return null;
-            }
-            throw error;
-        });
-    }
-    _getStat(filepath) {
-        return new Promise((resolve, reject) => {
-            this._stat(filepath, this._fsStatSettings, (error, stats) => {
-                return error === null ? resolve(stats) : reject(error);
-            });
-        });
-    }
-}
-exports.default = ReaderStream;

package/node_modules/fast-glob/out/readers/sync.d.ts

@@ -1,12 +0,0 @@
-import * as fsStat from '@nodelib/fs.stat';
-import * as fsWalk from '@nodelib/fs.walk';
-import { Entry, Pattern, ReaderOptions } from '../types';
-import Reader from './reader';
-export default class ReaderSync extends Reader<Entry[]> {
-    protected _walkSync: typeof fsWalk.walkSync;
-    protected _statSync: typeof fsStat.statSync;
-    dynamic(root: string, options: ReaderOptions): Entry[];
-    static(patterns: Pattern[], options: ReaderOptions): Entry[];
-    private _getEntry;
-    private _getStat;
-}

package/node_modules/fast-glob/out/readers/sync.js

@@ -1,43 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const fsStat = require("@nodelib/fs.stat");
-const fsWalk = require("@nodelib/fs.walk");
-const reader_1 = require("./reader");
-class ReaderSync extends reader_1.default {
-    constructor() {
-        super(...arguments);
-        this._walkSync = fsWalk.walkSync;
-        this._statSync = fsStat.statSync;
-    }
-    dynamic(root, options) {
-        return this._walkSync(root, options);
-    }
-    static(patterns, options) {
-        const entries = [];
-        for (const pattern of patterns) {
-            const filepath = this._getFullEntryPath(pattern);
-            const entry = this._getEntry(filepath, pattern, options);
-            if (entry === null || !options.entryFilter(entry)) {
-                continue;
-            }
-            entries.push(entry);
-        }
-        return entries;
-    }
-    _getEntry(filepath, pattern, options) {
-        try {
-            const stats = this._getStat(filepath);
-            return this._makeEntry(stats, pattern);
-        }
-        catch (error) {
-            if (options.errorFilter(error)) {
-                return null;
-            }
-            throw error;
-        }
-    }
-    _getStat(filepath) {
-        return this._statSync(filepath, this._fsStatSettings);
-    }
-}
-exports.default = ReaderSync;