@mintlify/common 1.0.1230 → 1.0.1232

package/dist/mdx/plugins/remark/remarkExtractTableOfContents.js

@@ -1,9 +1,10 @@
 import { visit } from 'unist-util-visit';
+import { normalizeGroups } from '../../../navigation/groupAccess.js';
 import { safeCleanHeadingId, slugify } from '../../../slugify.js';
 import { createMdxJsxAttribute, getTableOfContentsTitle, getTitleMarkdownText, } from '../../lib/remark-utils.js';
 import { isMdxJsxFragment } from '../../utils.js';
 import { AVOIDED_PAGE_MODES, HEADING_LEVELS } from './remarkComponentIds.js';
-import { isHiddenFromHumans, isVisibilityElement, resolveVisibilityFor, toVisibilityAuthRule, } from './remarkVisibilityForMarkdown.js';
+import { isHiddenFromHumans, isVisibilityElement, resolveVisibilityFor, toPageGroups, toVisibilityAuthRule, } from './remarkVisibilityForMarkdown.js';
 import { isVariationElement, resolveVariationIds } from './variation.js';
 export const HEADING_NAMES = ['h1', 'h2', 'h3', 'h4'];
 const COMPONENTS_TO_EXCLUDE_HEADINGS = [
@@ -20,7 +21,13 @@ function getStringAttribute(attributes, name) {
     }
     return undefined;
 }
-const authRuleKey = (rule) => typeof rule === 'string' ? rule : JSON.stringify([...rule.groups].sort());
+const sortedGroups = (groups) => groups && [...groups].sort();
+const authRuleKey = (rule) => {
+    if (typeof rule === 'string')
+        return rule;
+    const normalized = normalizeGroups(toPageGroups(rule.groups));
+    return JSON.stringify([sortedGroups(normalized === null || normalized === void 0 ? void 0 : normalized.includes), sortedGroups(normalized === null || normalized === void 0 ? void 0 : normalized.excludes)]);
+};
 const hasAuthRules = (childRules, parentRules) => {
     if (parentRules === undefined)
         return true;

package/dist/mdx/plugins/remark/remarkVisibilityForMarkdown.d.ts

@@ -1,3 +1,4 @@
+import type { PageGroupRule, PageGroups } from '@mintlify/models';
 import type { Root } from 'mdast';
 import type { MdxJsxFlowElement, MdxJsxTextElement } from 'mdast-util-mdx-jsx';
 export type MdxJsxElement = MdxJsxFlowElement | MdxJsxTextElement;
@@ -8,9 +9,11 @@ export declare function isVisibilityElement(node: {
 export declare const VISIBILITY_AUDIENCES: readonly ["humans", "agents", "signed-in", "signed-out"];
 export type VisibilityAudience = (typeof VISIBILITY_AUDIENCES)[number];
 export declare const VISIBILITY_FOR_EXPECTED = "\"humans\", \"agents\", \"signed-in\", \"signed-out\", or { groups: [...] }";
-export type VisibilityAuthRule = 'signed-in' | 'signed-out' | {
-    groups: string[];
+export type VisibilityGroups = string[] | PageGroupRule;
+export type VisibilityGroupsRule = {
+    groups: VisibilityGroups;
 };
+export type VisibilityAuthRule = 'signed-in' | 'signed-out' | VisibilityGroupsRule;
 export type VisibilityViewer = {
     signedIn: boolean;
     groups: readonly string[];
@@ -20,7 +23,7 @@ export type VisibilityResolution = {
     audience: VisibilityAudience;
 } | {
     kind: 'groups';
-    groups: string[];
+    groups: VisibilityGroups;
 } | {
     kind: 'invalid';
     raw: string;
@@ -30,6 +33,8 @@ export type VisibilityResolution = {
     kind: 'missing';
 };
 export declare function isVisibilityAudience(value: unknown): value is VisibilityAudience;
+export declare const toPageGroups: (groups: VisibilityGroups) => PageGroups;
+export declare function toVisibilityGroupsRule(value: unknown): VisibilityGroupsRule | undefined;
 export declare function resolveVisibilityFor(node: MdxJsxElement): VisibilityResolution;
 export declare function isHiddenFromHumans(resolution: VisibilityResolution): boolean;
 export declare function isHiddenFromAgents(resolution: VisibilityResolution): boolean;

package/dist/mdx/plugins/remark/remarkVisibilityForMarkdown.js

@@ -1,3 +1,4 @@
+import { WILDCARD_GROUP, checkGroupAccess, isPageGroups } from '../../../navigation/groupAccess.js';
 export function isVisibilityElement(node) {
     return ((node.type === 'mdxJsxFlowElement' || node.type === 'mdxJsxTextElement') &&
         node.name === 'Visibility');
@@ -42,19 +43,68 @@ function foldString(node) {
             return undefined;
     }
 }
+const trimGroupNames = (names) => [...new Set(names.map((name) => name.trim()))];
+const isGroupNames = (groups) => groups.every((entry) => typeof entry === 'string');
+export const toPageGroups = (groups) => Array.isArray(groups) ? groups : [groups];
+function toVisibilityGroups(value) {
+    if (Array.isArray(value)) {
+        if (value.length === 0 || !isPageGroups(value) || !isGroupNames(value))
+            return undefined;
+        const names = trimGroupNames(value);
+        return isPageGroups(names) ? names : undefined;
+    }
+    const rules = [value];
+    if (!isPageGroups(rules) || isGroupNames(rules))
+        return undefined;
+    const [rule] = rules.map(({ includes, excludes }) => (Object.assign(Object.assign({}, (includes && { includes: trimGroupNames(includes) })), (excludes && { excludes: trimGroupNames(excludes) }))));
+    return rule && isPageGroups([rule]) ? rule : undefined;
+}
+export function toVisibilityGroupsRule(value) {
+    if (!isRecord(value) || Object.keys(value).length !== 1)
+        return undefined;
+    const groups = toVisibilityGroups(value.groups);
+    return groups && { groups };
+}
+function staticKey(property) {
+    if (property.type !== 'Property' || property.computed)
+        return undefined;
+    if (property.key.type === 'Identifier')
+        return property.key.name;
+    return property.key.type === 'Literal' && typeof property.key.value === 'string'
+        ? property.key.value
+        : undefined;
+}
+function foldGroupNames(array) {
+    const names = array.elements.map((element) => foldString(element));
+    return names.every((name) => name !== undefined) ? names : undefined;
+}
+function foldGroupRule(object) {
+    const rule = {};
+    for (const property of object.properties) {
+        const key = staticKey(property);
+        if (property.type !== 'Property' || (key !== 'includes' && key !== 'excludes')) {
+            return undefined;
+        }
+        const names = property.value.type === 'ArrayExpression' ? foldGroupNames(property.value) : undefined;
+        if (!names)
+            return undefined;
+        rule[key] = names;
+    }
+    return rule;
+}
 function resolveGroups(value) {
     const expression = expressionOf(value);
     if ((expression === null || expression === void 0 ? void 0 : expression.type) !== 'ObjectExpression' || expression.properties.length !== 1)
         return undefined;
     const [property] = expression.properties;
-    if ((property === null || property === void 0 ? void 0 : property.type) !== 'Property' || property.computed)
-        return undefined;
-    const key = property.key.type === 'Identifier' ? property.key.name : undefined;
-    const literalKey = property.key.type === 'Literal' ? property.key.value : undefined;
-    if ((key !== null && key !== void 0 ? key : literalKey) !== 'groups' || property.value.type !== 'ArrayExpression')
+    if ((property === null || property === void 0 ? void 0 : property.type) !== 'Property' || staticKey(property) !== 'groups')
         return undefined;
-    const groups = property.value.elements.map((element) => { var _a, _b; return (_b = (_a = foldString(element)) === null || _a === void 0 ? void 0 : _a.trim()) !== null && _b !== void 0 ? _b : ''; });
-    return groups.length > 0 && groups.every(Boolean) ? [...new Set(groups)] : undefined;
+    if (property.value.type === 'ObjectExpression') {
+        return toVisibilityGroups(foldGroupRule(property.value));
+    }
+    return property.value.type === 'ArrayExpression'
+        ? toVisibilityGroups(foldGroupNames(property.value))
+        : undefined;
 }
 function mayOverrideFor(attr) {
     if (attr.type !== 'mdxJsxExpressionAttribute')
@@ -172,7 +222,7 @@ export function matchesVisibilityAuthRule(rule, viewer) {
         return viewer.signedIn;
     if (rule === 'signed-out')
         return !viewer.signedIn;
-    return viewer.signedIn && rule.groups.some((group) => viewer.groups.includes(group));
+    return checkGroupAccess(toPageGroups(rule.groups), new Set(viewer.signedIn ? [...viewer.groups, WILDCARD_GROUP] : []));
 }
 // `export * from` is intentionally ignored: it exposes no statically-knowable
 // names and creates no page-local JSX bindings in MDX, so there is nothing to