directus 9.24.0 → 9.25.0

package/dist/utils/merge-permissions.js

@@ -1,100 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergePermission = exports.mergePermissions = void 0;
-const lodash_1 = require("lodash");
-function mergePermissions(strategy, ...permissions) {
-    const allPermissions = (0, lodash_1.flatten)(permissions);
-    const mergedPermissions = allPermissions
-        .reduce((acc, val) => {
-        const key = `${val.collection}__${val.action}__${val.role || '$PUBLIC'}`;
-        const current = acc.get(key);
-        acc.set(key, current ? mergePermission(strategy, current, val) : val);
-        return acc;
-    }, new Map())
-        .values();
-    return Array.from(mergedPermissions);
-}
-exports.mergePermissions = mergePermissions;
-function mergePermission(strategy, currentPerm, newPerm) {
-    const logicalKey = `_${strategy}`;
-    let permissions = currentPerm.permissions;
-    let validation = currentPerm.validation;
-    let fields = currentPerm.fields;
-    let presets = currentPerm.presets;
-    if (newPerm.permissions) {
-        if (currentPerm.permissions && Object.keys(currentPerm.permissions)[0] === logicalKey) {
-            permissions = {
-                [logicalKey]: [
-                    ...currentPerm.permissions[logicalKey],
-                    newPerm.permissions,
-                ],
-            };
-        }
-        else if (currentPerm.permissions) {
-            // Empty {} supersedes other permissions in _OR merge
-            if (strategy === 'or' && ((0, lodash_1.isEqual)(currentPerm.permissions, {}) || (0, lodash_1.isEqual)(newPerm.permissions, {}))) {
-                permissions = {};
-            }
-            else {
-                permissions = {
-                    [logicalKey]: [currentPerm.permissions, newPerm.permissions],
-                };
-            }
-        }
-        else {
-            permissions = {
-                [logicalKey]: [newPerm.permissions],
-            };
-        }
-    }
-    if (newPerm.validation) {
-        if (currentPerm.validation && Object.keys(currentPerm.validation)[0] === logicalKey) {
-            validation = {
-                [logicalKey]: [
-                    ...currentPerm.validation[logicalKey],
-                    newPerm.validation,
-                ],
-            };
-        }
-        else if (currentPerm.validation) {
-            // Empty {} supersedes other validations in _OR merge
-            if (strategy === 'or' && ((0, lodash_1.isEqual)(currentPerm.validation, {}) || (0, lodash_1.isEqual)(newPerm.validation, {}))) {
-                validation = {};
-            }
-            else {
-                validation = {
-                    [logicalKey]: [currentPerm.validation, newPerm.validation],
-                };
-            }
-        }
-        else {
-            validation = {
-                [logicalKey]: [newPerm.validation],
-            };
-        }
-    }
-    if (newPerm.fields) {
-        if (Array.isArray(currentPerm.fields) && strategy === 'or') {
-            fields = [...new Set([...currentPerm.fields, ...newPerm.fields])];
-        }
-        else if (Array.isArray(currentPerm.fields) && strategy === 'and') {
-            fields = (0, lodash_1.intersection)(currentPerm.fields, newPerm.fields);
-        }
-        else {
-            fields = newPerm.fields;
-        }
-        if (fields.includes('*'))
-            fields = ['*'];
-    }
-    if (newPerm.presets) {
-        presets = (0, lodash_1.merge)({}, presets, newPerm.presets);
-    }
-    return (0, lodash_1.omit)({
-        ...currentPerm,
-        permissions,
-        validation,
-        fields,
-        presets,
-    }, ['id', 'system']);
-}
-exports.mergePermission = mergePermission;

package/dist/utils/merge-permissions.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/utils/parse-image-metadata.d.ts

@@ -1,3 +0,0 @@
-/// <reference types="node" />
-export declare function parseIptc(buffer: Buffer): Record<string, unknown>;
-export declare function parseXmp(buffer: Buffer): Record<string, unknown>;

package/dist/utils/parse-image-metadata.js

@@ -1,73 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseXmp = exports.parseIptc = void 0;
-const IPTC_ENTRY_TYPES = new Map([
-    [0x78, 'caption'],
-    [0x6e, 'credit'],
-    [0x19, 'keywords'],
-    [0x37, 'dateCreated'],
-    [0x50, 'byline'],
-    [0x55, 'bylineTitle'],
-    [0x7a, 'captionWriter'],
-    [0x69, 'headline'],
-    [0x74, 'copyright'],
-    [0x0f, 'category'],
-]);
-const IPTC_ENTRY_MARKER = Buffer.from([0x1c, 0x02]);
-function parseIptc(buffer) {
-    if (!Buffer.isBuffer(buffer))
-        return {};
-    const iptc = {};
-    let lastIptcEntryPos = buffer.indexOf(IPTC_ENTRY_MARKER);
-    while (lastIptcEntryPos !== -1) {
-        lastIptcEntryPos = buffer.indexOf(IPTC_ENTRY_MARKER, lastIptcEntryPos + IPTC_ENTRY_MARKER.byteLength);
-        const iptcBlockTypePos = lastIptcEntryPos + IPTC_ENTRY_MARKER.byteLength;
-        const iptcBlockSizePos = iptcBlockTypePos + 1;
-        const iptcBlockDataPos = iptcBlockSizePos + 2;
-        const iptcBlockType = buffer.readUInt8(iptcBlockTypePos);
-        const iptcBlockSize = buffer.readUInt16BE(iptcBlockSizePos);
-        if (!IPTC_ENTRY_TYPES.has(iptcBlockType)) {
-            continue;
-        }
-        const iptcBlockTypeId = IPTC_ENTRY_TYPES.get(iptcBlockType);
-        const iptcData = buffer.subarray(iptcBlockDataPos, iptcBlockDataPos + iptcBlockSize).toString();
-        if (iptcBlockTypeId) {
-            if (iptc[iptcBlockTypeId] == null) {
-                iptc[iptcBlockTypeId] = iptcData;
-            }
-            else if (Array.isArray(iptc[iptcBlockTypeId])) {
-                iptc[iptcBlockTypeId].push(iptcData);
-            }
-            else {
-                iptc[iptcBlockTypeId] = [iptc[iptcBlockTypeId], iptcData];
-            }
-        }
-    }
-    return iptc;
-}
-exports.parseIptc = parseIptc;
-function parseXmp(buffer) {
-    const xmp = {};
-    ['title', 'description', 'rights', 'creator', 'subject'].forEach((x) => {
-        const tagRegex = new RegExp(`<dc:${x}>(.*?)</dc:${x}>`, 'smig'), tagMatches = tagRegex.exec(buffer.toString());
-        if (!tagMatches || tagMatches.length === 0) {
-            return;
-        }
-        const value = tagMatches[1]?.trim();
-        if (value?.toLowerCase().indexOf('<rdf:bag>') === 0) {
-            const r = new RegExp('<rdf:li>(.*?)</rdf:li>', 'smig');
-            let match = r.exec(value);
-            const result = [];
-            while (match) {
-                result.push(match[1]);
-                match = r.exec(value);
-            }
-            xmp[x] = result;
-        }
-        else {
-            xmp[x] = value?.replace(/<[^>]*>?/gm, '').trim();
-        }
-    });
-    return xmp;
-}
-exports.parseXmp = parseXmp;

package/dist/utils/reduce-schema.d.ts

@@ -1,9 +0,0 @@
-import type { Permission, PermissionsAction, SchemaOverview } from '@directus/shared/types';
-/**
- * Reduces the schema based on the included permissions. The resulting object is the schema structure, but with only
- * the allowed collections/fields/relations included based on the permissions.
- * @param schema The full project schema
- * @param actions Array of permissions actions (crud)
- * @returns Reduced schema
- */
-export declare function reduceSchema(schema: SchemaOverview, permissions: Permission[] | null, actions?: PermissionsAction[]): SchemaOverview;

package/dist/utils/reduce-schema.js

@@ -1,82 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.reduceSchema = void 0;
-const lodash_1 = require("lodash");
-/**
- * Reduces the schema based on the included permissions. The resulting object is the schema structure, but with only
- * the allowed collections/fields/relations included based on the permissions.
- * @param schema The full project schema
- * @param actions Array of permissions actions (crud)
- * @returns Reduced schema
- */
-function reduceSchema(schema, permissions, actions = ['create', 'read', 'update', 'delete']) {
-    const reduced = {
-        collections: {},
-        relations: [],
-    };
-    const allowedFieldsInCollection = permissions
-        ?.filter((permission) => actions.includes(permission.action))
-        .reduce((acc, permission) => {
-        if (!acc[permission.collection]) {
-            acc[permission.collection] = [];
-        }
-        if (permission.fields) {
-            acc[permission.collection] = (0, lodash_1.uniq)([...acc[permission.collection], ...permission.fields]);
-        }
-        return acc;
-    }, {}) ?? {};
-    for (const [collectionName, collection] of Object.entries(schema.collections)) {
-        if (!permissions?.some((permission) => permission.collection === collectionName && actions.includes(permission.action))) {
-            continue;
-        }
-        const fields = {};
-        for (const [fieldName, field] of Object.entries(schema.collections[collectionName].fields)) {
-            if (!allowedFieldsInCollection[collectionName]?.includes('*') &&
-                !allowedFieldsInCollection[collectionName]?.includes(fieldName)) {
-                continue;
-            }
-            const o2mRelation = schema.relations.find((relation) => relation.related_collection === collectionName && relation.meta?.one_field === fieldName);
-            if (o2mRelation &&
-                !permissions?.some((permission) => permission.collection === o2mRelation.collection && actions.includes(permission.action))) {
-                continue;
-            }
-            fields[fieldName] = field;
-        }
-        reduced.collections[collectionName] = {
-            ...collection,
-            fields,
-        };
-    }
-    reduced.relations = schema.relations.filter((relation) => {
-        let collectionsAllowed = true;
-        let fieldsAllowed = true;
-        if (Object.keys(allowedFieldsInCollection).includes(relation.collection) === false) {
-            collectionsAllowed = false;
-        }
-        if (relation.related_collection &&
-            (Object.keys(allowedFieldsInCollection).includes(relation.related_collection) === false ||
-                // Ignore legacy permissions with an empty fields array
-                allowedFieldsInCollection[relation.related_collection]?.length === 0)) {
-            collectionsAllowed = false;
-        }
-        if (relation.meta?.one_allowed_collections &&
-            relation.meta.one_allowed_collections.every((collection) => Object.keys(allowedFieldsInCollection).includes(collection)) === false) {
-            collectionsAllowed = false;
-        }
-        if (!allowedFieldsInCollection[relation.collection] ||
-            (allowedFieldsInCollection[relation.collection]?.includes('*') === false &&
-                allowedFieldsInCollection[relation.collection]?.includes(relation.field) === false)) {
-            fieldsAllowed = false;
-        }
-        if (relation.related_collection &&
-            relation.meta?.one_field &&
-            (!allowedFieldsInCollection[relation.related_collection] ||
-                (allowedFieldsInCollection[relation.related_collection]?.includes('*') === false &&
-                    allowedFieldsInCollection[relation.related_collection]?.includes(relation.meta?.one_field) === false))) {
-            fieldsAllowed = false;
-        }
-        return collectionsAllowed && fieldsAllowed;
-    });
-    return reduced;
-}
-exports.reduceSchema = reduceSchema;

package/dist/utils/require-yaml.d.ts

@@ -1 +0,0 @@
-export declare function requireYAML(filepath: string): Record<string, any>;

package/dist/utils/require-yaml.js

@@ -1,13 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.requireYAML = void 0;
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const js_yaml_1 = __importDefault(require("js-yaml"));
-function requireYAML(filepath) {
-    const yamlRaw = fs_extra_1.default.readFileSync(filepath, 'utf8');
-    return js_yaml_1.default.load(yamlRaw);
-}
-exports.requireYAML = requireYAML;

package/dist/utils/sanitize-query.d.ts

@@ -1,2 +0,0 @@
-import type { Accountability, Query } from '@directus/shared/types';
-export declare function sanitizeQuery(rawQuery: Record<string, any>, accountability?: Accountability | null): Query;

package/dist/utils/sanitize-query.js

@@ -1,179 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sanitizeQuery = void 0;
-const utils_1 = require("@directus/shared/utils");
-const lodash_1 = require("lodash");
-const logger_1 = __importDefault(require("../logger"));
-const types_1 = require("../types");
-function sanitizeQuery(rawQuery, accountability) {
-    const query = {};
-    if (rawQuery['limit'] !== undefined) {
-        const limit = sanitizeLimit(rawQuery['limit']);
-        if (typeof limit === 'number') {
-            query.limit = limit;
-        }
-    }
-    if (rawQuery['fields']) {
-        query.fields = sanitizeFields(rawQuery['fields']);
-    }
-    if (rawQuery['groupBy']) {
-        query.group = sanitizeFields(rawQuery['groupBy']);
-    }
-    if (rawQuery['aggregate']) {
-        query.aggregate = sanitizeAggregate(rawQuery['aggregate']);
-    }
-    if (rawQuery['sort']) {
-        query.sort = sanitizeSort(rawQuery['sort']);
-    }
-    if (rawQuery['filter']) {
-        query.filter = sanitizeFilter(rawQuery['filter'], accountability || null);
-    }
-    if (rawQuery['offset']) {
-        query.offset = sanitizeOffset(rawQuery['offset']);
-    }
-    if (rawQuery['page']) {
-        query.page = sanitizePage(rawQuery['page']);
-    }
-    if (rawQuery['meta']) {
-        query.meta = sanitizeMeta(rawQuery['meta']);
-    }
-    if (rawQuery['search'] && typeof rawQuery['search'] === 'string') {
-        query.search = rawQuery['search'];
-    }
-    if (rawQuery['export']) {
-        query.export = rawQuery['export'];
-    }
-    if (rawQuery['deep']) {
-        if (!query.deep)
-            query.deep = {};
-        query.deep = sanitizeDeep(rawQuery['deep'], accountability);
-    }
-    if (rawQuery['alias']) {
-        query.alias = sanitizeAlias(rawQuery['alias']);
-    }
-    return query;
-}
-exports.sanitizeQuery = sanitizeQuery;
-function sanitizeFields(rawFields) {
-    if (!rawFields)
-        return null;
-    let fields = [];
-    if (typeof rawFields === 'string')
-        fields = rawFields.split(',');
-    else if (Array.isArray(rawFields))
-        fields = rawFields;
-    // Case where array item includes CSV (fe fields[]=id,name):
-    fields = (0, lodash_1.flatten)(fields.map((field) => (field.includes(',') ? field.split(',') : field)));
-    fields = fields.map((field) => field.trim());
-    return fields;
-}
-function sanitizeSort(rawSort) {
-    let fields = [];
-    if (typeof rawSort === 'string')
-        fields = rawSort.split(',');
-    else if (Array.isArray(rawSort))
-        fields = rawSort;
-    return fields;
-}
-function sanitizeAggregate(rawAggregate) {
-    let aggregate = rawAggregate;
-    if (typeof rawAggregate === 'string') {
-        try {
-            aggregate = (0, utils_1.parseJSON)(rawAggregate);
-        }
-        catch {
-            logger_1.default.warn('Invalid value passed for filter query parameter.');
-        }
-    }
-    for (const [operation, fields] of Object.entries(aggregate)) {
-        if (typeof fields === 'string')
-            aggregate[operation] = fields.split(',');
-        else if (Array.isArray(fields))
-            aggregate[operation] = fields;
-    }
-    return aggregate;
-}
-function sanitizeFilter(rawFilter, accountability) {
-    let filters = rawFilter;
-    if (typeof rawFilter === 'string') {
-        try {
-            filters = (0, utils_1.parseJSON)(rawFilter);
-        }
-        catch {
-            logger_1.default.warn('Invalid value passed for filter query parameter.');
-        }
-    }
-    return (0, utils_1.parseFilter)(filters, accountability);
-}
-function sanitizeLimit(rawLimit) {
-    if (rawLimit === undefined || rawLimit === null)
-        return null;
-    return Number(rawLimit);
-}
-function sanitizeOffset(rawOffset) {
-    return Number(rawOffset);
-}
-function sanitizePage(rawPage) {
-    return Number(rawPage);
-}
-function sanitizeMeta(rawMeta) {
-    if (rawMeta === '*') {
-        return Object.values(types_1.Meta);
-    }
-    if (rawMeta.includes(',')) {
-        return rawMeta.split(',');
-    }
-    if (Array.isArray(rawMeta)) {
-        return rawMeta;
-    }
-    return [rawMeta];
-}
-function sanitizeDeep(deep, accountability) {
-    const result = {};
-    if (typeof deep === 'string') {
-        try {
-            deep = (0, utils_1.parseJSON)(deep);
-        }
-        catch {
-            logger_1.default.warn('Invalid value passed for deep query parameter.');
-        }
-    }
-    parse(deep);
-    return result;
-    function parse(level, path = []) {
-        const parsedLevel = {};
-        for (const [key, value] of Object.entries(level)) {
-            if (!key)
-                break;
-            if (key.startsWith('_')) {
-                // Sanitize query only accepts non-underscore-prefixed query options
-                const parsedSubQuery = sanitizeQuery({ [key.substring(1)]: value }, accountability);
-                // ...however we want to keep them for the nested structure of deep, otherwise there's no
-                // way of knowing when to keep nesting and when to stop
-                const [parsedKey, parsedValue] = Object.entries(parsedSubQuery)[0];
-                parsedLevel[`_${parsedKey}`] = parsedValue;
-            }
-            else if ((0, lodash_1.isPlainObject)(value)) {
-                parse(value, [...path, key]);
-            }
-        }
-        if (Object.keys(parsedLevel).length > 0) {
-            (0, lodash_1.set)(result, path, (0, lodash_1.merge)({}, (0, lodash_1.get)(result, path, {}), parsedLevel));
-        }
-    }
-}
-function sanitizeAlias(rawAlias) {
-    let alias = rawAlias;
-    if (typeof rawAlias === 'string') {
-        try {
-            alias = (0, utils_1.parseJSON)(rawAlias);
-        }
-        catch (err) {
-            logger_1.default.warn('Invalid value passed for alias query parameter.');
-        }
-    }
-    return alias;
-}

package/dist/utils/sanitize-query.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/utils/sanitize-schema.d.ts

@@ -1,30 +0,0 @@
-import type { Field, Relation } from '@directus/shared/types';
-import type { Collection } from '../types';
-/**
- * Pick certain database vendor specific collection properties that should be compared when performing diff
- *
- * @param collection collection to sanitize
- * @returns sanitized collection
- *
- * @see {@link https://github.com/knex/knex-schema-inspector/blob/master/lib/types/table.ts}
- */
-export declare function sanitizeCollection(collection: Collection | undefined): Partial<Collection> | undefined;
-/**
- * Pick certain database vendor specific field properties that should be compared when performing diff
- *
- * @param field field to sanitize
- * @param sanitizeAllSchema Whether or not the whole field schema should be sanitized. Mainly used to prevent modifying autoincrement fields
- * @returns sanitized field
- *
- * @see {@link https://github.com/knex/knex-schema-inspector/blob/master/lib/types/column.ts}
- */
-export declare function sanitizeField(field: Field | undefined, sanitizeAllSchema?: boolean): Partial<Field> | undefined;
-/**
- * Pick certain database vendor specific relation properties that should be compared when performing diff
- *
- * @param relation relation to sanitize
- * @returns sanitized relation
- *
- * @see {@link https://github.com/knex/knex-schema-inspector/blob/master/lib/types/foreign-key.ts}
- */
-export declare function sanitizeRelation(relation: Relation | undefined): Partial<Relation> | undefined;

package/dist/utils/sanitize-schema.js

@@ -1,80 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sanitizeRelation = exports.sanitizeField = exports.sanitizeCollection = void 0;
-const lodash_1 = require("lodash");
-/**
- * Pick certain database vendor specific collection properties that should be compared when performing diff
- *
- * @param collection collection to sanitize
- * @returns sanitized collection
- *
- * @see {@link https://github.com/knex/knex-schema-inspector/blob/master/lib/types/table.ts}
- */
-function sanitizeCollection(collection) {
-    if (!collection)
-        return collection;
-    return (0, lodash_1.pick)(collection, ['collection', 'fields', 'meta', 'schema.name']);
-}
-exports.sanitizeCollection = sanitizeCollection;
-/**
- * Pick certain database vendor specific field properties that should be compared when performing diff
- *
- * @param field field to sanitize
- * @param sanitizeAllSchema Whether or not the whole field schema should be sanitized. Mainly used to prevent modifying autoincrement fields
- * @returns sanitized field
- *
- * @see {@link https://github.com/knex/knex-schema-inspector/blob/master/lib/types/column.ts}
- */
-function sanitizeField(field, sanitizeAllSchema = false) {
-    if (!field)
-        return field;
-    const defaultPaths = ['collection', 'field', 'type', 'meta', 'name', 'children'];
-    const pickedPaths = sanitizeAllSchema
-        ? defaultPaths
-        : [
-            ...defaultPaths,
-            'schema.name',
-            'schema.table',
-            'schema.data_type',
-            'schema.default_value',
-            'schema.max_length',
-            'schema.numeric_precision',
-            'schema.numeric_scale',
-            'schema.is_nullable',
-            'schema.is_unique',
-            'schema.is_primary_key',
-            'schema.is_generated',
-            'schema.generation_expression',
-            'schema.has_auto_increment',
-            'schema.foreign_key_table',
-            'schema.foreign_key_column',
-        ];
-    return (0, lodash_1.pick)(field, pickedPaths);
-}
-exports.sanitizeField = sanitizeField;
-/**
- * Pick certain database vendor specific relation properties that should be compared when performing diff
- *
- * @param relation relation to sanitize
- * @returns sanitized relation
- *
- * @see {@link https://github.com/knex/knex-schema-inspector/blob/master/lib/types/foreign-key.ts}
- */
-function sanitizeRelation(relation) {
-    if (!relation)
-        return relation;
-    return (0, lodash_1.pick)(relation, [
-        'collection',
-        'field',
-        'related_collection',
-        'meta',
-        'schema.table',
-        'schema.column',
-        'schema.foreign_key_table',
-        'schema.foreign_key_column',
-        'schema.constraint_name',
-        'schema.on_update',
-        'schema.on_delete',
-    ]);
-}
-exports.sanitizeRelation = sanitizeRelation;

package/dist/utils/sanitize-schema.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/utils/should-skip-cache.d.ts

@@ -1,7 +0,0 @@
-import type { Request } from 'express';
-/**
- * Whether to skip caching for the current request
- *
- * @param req Express request object
- */
-export declare function shouldSkipCache(req: Request): boolean;

package/dist/utils/should-skip-cache.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.shouldSkipCache = void 0;
-const env_1 = require("../env");
-const url_1 = require("./url");
-/**
- * Whether to skip caching for the current request
- *
- * @param req Express request object
- */
-function shouldSkipCache(req) {
-    const env = (0, env_1.getEnv)();
-    // Always skip cache for requests coming from the data studio based on Referer header
-    const referer = req.get('Referer');
-    if (referer) {
-        const adminUrl = new url_1.Url(env['PUBLIC_URL']).addPath('admin');
-        if (adminUrl.isRootRelative()) {
-            const refererUrl = new url_1.Url(referer);
-            if (refererUrl.path.join('/').startsWith(adminUrl.path.join('/')))
-                return true;
-        }
-        else if (referer.startsWith(adminUrl.toString())) {
-            return true;
-        }
-    }
-    if (env['CACHE_SKIP_ALLOWED'] && req.get('cache-control')?.includes('no-store'))
-        return true;
-    return false;
-}
-exports.shouldSkipCache = shouldSkipCache;

package/dist/utils/should-skip-cache.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/utils/stall.d.ts

@@ -1,26 +0,0 @@
-/**
- * Wait a specific time to meet the stall ms. Useful in cases where you need to make sure that every
- * path in a function takes at least X ms (for example authenticate).
- *
- * @param {number} ms - Stall time to wait until
- * @param {number} start - Current start time of the function
- *
- * @example
- *
- * ```js
- * const STALL_TIME = 100;
- *
- * // Function will always take (at least) 100ms
- * async function doSomething() {
- *   const timeStart = performance.now();
- *
- *   if (something === true) {
- *     await heavy();
- *   }
- *
- *   stall(STALL_TIME, timeStart);
- *   return 'result';
- * }
- * ```
- */
-export declare function stall(ms: number, start: number): Promise<void>;