@mintlify/validation 0.1.121 → 0.1.122

package/dist/mint-config/validateVersionsInNavigation.d.ts

@@ -1,4 +0,0 @@
-import { VersionType, NavigationEntry, NavigationGroup } from '@mintlify/models';
-import { MintValidationResults } from './common.js';
-export declare function flattenNavigationVersions(nav: NavigationEntry[], versions?: string[]): string[];
-export declare function validateVersionsInNavigation(navigation: NavigationGroup[] | undefined, versions?: VersionType[] | undefined): MintValidationResults;

package/dist/mint-config/validateVersionsInNavigation.js

@@ -1,52 +0,0 @@
-import { MintValidationResults } from './common.js';
-import { navigationSchema } from './schemas/navigation.js';
-export function flattenNavigationVersions(nav, versions = []) {
-    nav.forEach((val) => {
-        if (val == null || typeof val === 'string') {
-            return versions;
-        }
-        if (val.version) {
-            versions.push(val.version);
-        }
-        if (!Array.isArray(val.pages)) {
-            return versions;
-        }
-        return flattenNavigationVersions(val.pages, versions);
-    });
-    return versions;
-}
-export function validateVersionsInNavigation(navigation, versions = []) {
-    const results = new MintValidationResults();
-    if (navigation == null || !navigationSchema.safeParse(navigation).success) {
-        return results;
-    }
-    const versionsFromNavigation = flattenNavigationVersions(navigation);
-    versionsFromNavigation.forEach((v) => {
-        if (versions && !versions.includes(v)) {
-            results.errors.push(`Version ${v} is not included in the versions array, but is used in the navigation. Please add ${v} to the versions array.`);
-        }
-    });
-    if (versionsFromNavigation.length === 0 && versions.length > 0) {
-        results.warnings.push('You have versions defined in the config, but no versions are used in the navigation.');
-    }
-    navigation.forEach((nav) => {
-        results.warnings.push(...warnVersionNesting(nav, null));
-    });
-    return results;
-}
-function warnVersionNesting(navigation, currentVersion) {
-    if (typeof navigation === 'string') {
-        return [];
-    }
-    const warnings = [];
-    if (navigation.version && currentVersion != null && navigation.version !== currentVersion) {
-        warnings.push(`Please do not set versions on groups nested inside a group that already has a version. The group "${navigation.group}" has version "${navigation.version}" set and it is nested in a group that has the version "${currentVersion}" set.`);
-    }
-    if (navigation.pages) {
-        return warnings.concat(navigation.pages
-            .map((entry) => warnVersionNesting(entry, currentVersion || navigation.version))
-            .flat()
-            .filter(Boolean));
-    }
-    return [];
-}

package/dist/sort.d.ts

@@ -1,47 +0,0 @@
-import { SORT_DIRECTION, SortOptions } from '@mintlify/models';
-export declare function isArray(x: object): x is [];
-/**
- * Creates a comparison function for sorting purposes based on a given direction and an optional key.
- *
- * @template T - The type of the elements.
- *
- * @param direction - Specifies the direction for sorting (either ASCENDING or DESCENDING).
- * @param key - An optional key on which to base the sorting. If not provided, the object itself will be used.
- *
- * @returns A comparator function to be used with array's `sort` method.
- */
-export declare function comparer<T>(direction: SORT_DIRECTION, key?: keyof T): (x: T, y: T) => 1 | -1;
-/**
- * Sets a value for a specific key in the ordered object or array. If the value is an object, sorts it before setting.
- *
- * @template T - The type of the main object.
- * @template X - The type of the value to be set.
- *
- * @param key - The key or index where the value should be set.
- * @param value - The value to be set.
- * @param ordered - The target object or array where the value will be set.
- * @param direction - Optional sorting direction for the value if it's an object.
- */
-export declare function set<T, X>(key: keyof T | number, value: X, ordered: Partial<T> | [], direction?: SORT_DIRECTION): void;
-/**
- * Returns a setter function that can be used to set values in an ordered object based on keys and sorting options.
- *
- * @template T - The type of the main object.
- *
- * @param obj - The source object with values to be set.
- * @param ordered - The target object where values will be set in an ordered manner.
- *
- * @returns A setter function for specific keys of the source object.
- */
-export declare function getSetter<T>(obj: T & Partial<SortOptions<T>>, ordered: Partial<T>): (key: keyof T) => void;
-/**
- * Sorts an object based on the provided sorting options.
- *
- * @template T - The type of the object.
- *
- * @param obj - The object to be sorted.
- * @param options - Sorting options including direction and other parameters.
- *
- * @returns A new object with sorted entries.
- */
-export declare function sort<T extends object>(obj: T, options?: Readonly<SortOptions<T>>): T;

package/dist/sort.js

@@ -1,72 +0,0 @@
-import { SORT_DIRECTION } from '@mintlify/models';
-import { Sortable } from './sortable/Sortable.js';
-export function isArray(x) {
-    return Array.isArray(x);
-}
-/**
- * Creates a comparison function for sorting purposes based on a given direction and an optional key.
- *
- * @template T - The type of the elements.
- *
- * @param direction - Specifies the direction for sorting (either ASCENDING or DESCENDING).
- * @param key - An optional key on which to base the sorting. If not provided, the object itself will be used.
- *
- * @returns A comparator function to be used with array's `sort` method.
- */
-export function comparer(direction, key) {
-    return (x, y) => {
-        const a = key ? x[key] : x;
-        const b = key ? y[key] : y;
-        return direction === SORT_DIRECTION.ASCENDING ? (a > b ? 1 : -1) : a > b ? -1 : 1;
-    };
-}
-/**
- * Sets a value for a specific key in the ordered object or array. If the value is an object, sorts it before setting.
- *
- * @template T - The type of the main object.
- * @template X - The type of the value to be set.
- *
- * @param key - The key or index where the value should be set.
- * @param value - The value to be set.
- * @param ordered - The target object or array where the value will be set.
- * @param direction - Optional sorting direction for the value if it's an object.
- */
-export function set(key, value, ordered, direction) {
-    if (value && typeof value === 'object') {
-        ordered[key] = sort(value, {
-            direction: direction !== null && direction !== void 0 ? direction : SORT_DIRECTION.ASCENDING,
-        });
-    }
-    else {
-        ordered[key] = value;
-    }
-}
-/**
- * Returns a setter function that can be used to set values in an ordered object based on keys and sorting options.
- *
- * @template T - The type of the main object.
- *
- * @param obj - The source object with values to be set.
- * @param ordered - The target object where values will be set in an ordered manner.
- *
- * @returns A setter function for specific keys of the source object.
- */
-export function getSetter(obj, ordered) {
-    return (key) => {
-        const value = obj[key];
-        set(key, value, ordered, obj.direction);
-    };
-}
-/**
- * Sorts an object based on the provided sorting options.
- *
- * @template T - The type of the object.
- *
- * @param obj - The object to be sorted.
- * @param options - Sorting options including direction and other parameters.
- *
- * @returns A new object with sorted entries.
- */
-export function sort(obj, options = { direction: SORT_DIRECTION.ASCENDING }) {
-    return new Sortable(obj, options).sort();
-}

package/dist/sortable/Sortable.d.ts

@@ -1,28 +0,0 @@
-import { ISortable, SortOptions } from '@mintlify/models';
-/**
- * Provides functionality to sort a given object based on provided sort options.
- *
- * @template T - The type of the object to be sorted.
- */
-export declare class Sortable<T> implements ISortable<T> {
-    readonly obj: Readonly<T>;
-    readonly options: Readonly<SortOptions<T>>;
-    constructor(obj: Readonly<T>, options?: Readonly<SortOptions<T>>);
-    sort(out?: Partial<T> | []): T;
-    /**
-     * Creates a new sortable entity for a given object with optional sortable properties.
-     *
-     * @param obj - The object that is to be converted into a sortable.
-     *
-     * @returns A new sortable instance.
-     */
-    static createSortable<T>(obj: T & Partial<ISortable<T>>): Sortable<T>;
-    /**
-     * Creates a sortable entity from a given object and recursively does the same for its nested properties.
-     *
-     * @param obj - The root object to start from.
-     *
-     * @returns A new root sortable instance.
-     */
-    static createSortableRecursive<T = never>(obj: T & Partial<ISortable<T>>): Sortable<T>;
-}

package/dist/sortable/Sortable.js

@@ -1,117 +0,0 @@
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-import { SORT_DIRECTION } from '@mintlify/models';
-import { any } from '../any.js';
-import { comparer, getSetter, isArray, set } from '../sort.js';
-import { isSortable } from './isSortable.js';
-/**
- * Provides functionality to sort a given object based on provided sort options.
- *
- * @template T - The type of the object to be sorted.
- */
-export class Sortable {
-    constructor(obj, options = { direction: SORT_DIRECTION.ASCENDING }) {
-        this.obj = obj;
-        this.options = options;
-        if (typeof obj !== 'object' || !(obj instanceof Object))
-            return;
-        if (typeof obj === 'string' || obj instanceof String)
-            return;
-        this.obj = obj;
-        this.options = options;
-        if (obj instanceof Sortable) {
-            this.obj = obj.obj;
-            this.options = Object.assign(Object.assign({}, obj.options), options);
-        }
-        if (isSortable(this.obj)) {
-            const _a = this.obj, { options: opts } = _a, o = __rest(_a, ["options"]);
-            this.obj = o;
-            this.options = Object.assign(Object.assign({}, opts), this.options);
-        }
-    }
-    sort(out) {
-        const { order, direction } = this.options;
-        out = out !== null && out !== void 0 ? out : this.obj;
-        if (isArray(this.obj)) {
-            const length = this.obj.length;
-            const values = [...this.obj];
-            this.obj.splice(0, this.obj.length);
-            for (let i = 0; i < length; i++) {
-                set(i, values[i], out, this.options.direction);
-            }
-        }
-        else if (any(order)) {
-            const entries = order.sort(comparer(direction, 'index'));
-            const keys = entries.map((x) => x.key);
-            const values = Object.fromEntries(new Map(keys.map((x) => [x, this.obj[x]])));
-            entries.forEach((x) => out === null || out === void 0 ? true : delete out[x.key]);
-            for (const entry of entries) {
-                const set = getSetter(values, out);
-                set(entry.key);
-            }
-        }
-        else {
-            const keys = Object.keys(this.obj).sort(comparer(direction));
-            const values = Object.fromEntries(new Map(keys.map((x) => [x, this.obj[x]])));
-            keys.forEach((x) => out === null || out === void 0 ? true : delete out[x]);
-            for (const key of keys) {
-                const set = getSetter(values, out);
-                set(key);
-            }
-        }
-        return out;
-    }
-    /**
-     * Creates a new sortable entity for a given object with optional sortable properties.
-     *
-     * @param obj - The object that is to be converted into a sortable.
-     *
-     * @returns A new sortable instance.
-     */
-    static createSortable(obj) {
-        var _a, _b, _c;
-        const direction = (_b = (_a = obj.options) === null || _a === void 0 ? void 0 : _a.direction) !== null && _b !== void 0 ? _b : SORT_DIRECTION.ASCENDING;
-        let order = (_c = obj.options) === null || _c === void 0 ? void 0 : _c.order;
-        order = order !== null && order !== void 0 ? order : Object.keys(obj).map((key, index) => ({ key: key, index }));
-        const options = {
-            direction,
-            order,
-        };
-        if (typeof obj !== 'string') {
-            obj.options = options;
-        }
-        return new Sortable(obj, options);
-    }
-    /**
-     * Creates a sortable entity from a given object and recursively does the same for its nested properties.
-     *
-     * @param obj - The root object to start from.
-     *
-     * @returns A new root sortable instance.
-     */
-    static createSortableRecursive(obj) {
-        const isObject = typeof obj === 'object';
-        if (isArray(obj)) {
-            for (let i = 0; i < obj.length; i++) {
-                this.createSortableRecursive(obj[i]);
-            }
-        }
-        else if (isObject) {
-            const keys = Object.keys(obj);
-            for (const key of keys) {
-                const value = obj[key];
-                this.createSortableRecursive(value);
-            }
-        }
-        return this.createSortable(obj);
-    }
-}

package/dist/sortable/isSortable.d.ts

@@ -1,2 +0,0 @@
-import { ISortable } from '@mintlify/models';
-export declare function isSortable<T extends object>(obj: T & Partial<ISortable<T>>): obj is T & ISortable<T>;

package/dist/sortable/isSortable.js

@@ -1,7 +0,0 @@
-import { SORT_DIRECTION } from '@mintlify/models';
-export function isSortable(obj) {
-    return (obj != undefined &&
-        obj.options != undefined &&
-        obj.options.direction != undefined &&
-        obj.options.direction in SORT_DIRECTION);
-}