@mintlify/common 1.0.1238 → 1.0.1240

package/dist/css/tailwind.js

@@ -8,8 +8,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import postcss from 'postcss';
-import tailwindcss from 'tailwindcss-v3';
 import { MINTLIFY_TAILWIND_PREFIX } from '../index.js';
+import { cloneNodes, createContext, defaultExtractor, generateRules, NOT_ON_DEMAND, postProcessSteps, resolveConfig, } from './tailwindInternals.js';
 function removeDarkClassNamePrefix(css) {
     return css.replace(/\.mint-dark \*/g, '.dark *');
 }
@@ -25,35 +25,74 @@ function getAllSelectors(nodes) {
     }
     return selectors;
 }
-function getContent(content) {
-    const extensions = ['html', 'tsx', 'mdx'];
-    return extensions.map((extension) => ({ raw: content, extension }));
+// a postcss plugin instance re-hashes the whole config per call; one context per prefix instead
+const runtimes = new Map();
+// the context remembers every candidate it has classified; rebuild past this
+const CANDIDATE_CACHE_LIMIT = 100000;
+function candidateCount({ context }) {
+    return context.classCache.size + context.notClassCache.size;
+}
+function getRuntime(prefix) {
+    const cached = runtimes.get(prefix);
+    if (cached && candidateCount(cached) <= CANDIDATE_CACHE_LIMIT)
+        return cached;
+    const context = createContext(resolveConfig(Object.assign({ content: [], corePlugins: { preflight: false }, darkMode: 'class' }, (prefix && { prefix }))));
+    const runtime = { context, extract: defaultExtractor(context) };
+    runtimes.set(prefix, runtime);
+    return runtime;
+}
+// lines are deduped like tailwind's getClassCandidates; candidates are copied since v8 slices
+// would keep the whole page alive in the context's caches
+function collectCandidates(content, extract) {
+    const candidates = new Set([NOT_ON_DEMAND]);
+    const seenLines = new Set();
+    for (const rawLine of content.split('\n')) {
+        const line = rawLine.trim();
+        if (seenLines.has(line))
+            continue;
+        seenLines.add(line);
+        for (const candidate of extract(line)) {
+            if (candidate !== '!*')
+                candidates.add((' ' + candidate).slice(1));
+        }
+    }
+    return new Set([...candidates].sort());
+}
+function isComponentVariant(node) {
+    const raws = node.raws.tailwind;
+    return (typeof raws === 'object' &&
+        raws !== null &&
+        'parentLayer' in raws &&
+        raws.parentLayer === 'components');
+}
+function generateUtilities(content, prefix) {
+    const { context, extract } = getRuntime(prefix);
+    const rules = context.offsets.sort(generateRules(collectCandidates(content, extract), context));
+    const utilities = [];
+    // no components layer in this sheet, so tailwind drops those variants
+    const variants = [];
+    for (const [{ layer }, rule] of rules) {
+        if (layer === 'utilities')
+            utilities.push(rule);
+        else if (layer === 'variants' && !isComponentVariant(rule))
+            variants.push(rule);
+    }
+    const root = postcss.root();
+    root.append(cloneNodes(utilities, undefined, { layer: 'utilities' }));
+    if (variants.length > 0)
+        root.append(cloneNodes(variants, undefined, { layer: 'variants' }));
+    for (const step of postProcessSteps)
+        step(context)(root);
+    return root;
 }
 /** Get generated TailwindCSS from the content with prefix added to each class */
 export function getDynamicTailwindCss(_a) {
     return __awaiter(this, arguments, void 0, function* ({ content, prefix = MINTLIFY_TAILWIND_PREFIX, }) {
-        const css = `@tailwind utilities;`;
-        const tailwindPlugin = tailwindcss({
-            content: getContent(content),
-            corePlugins: { preflight: false },
-            prefix,
-            darkMode: 'class',
-        });
-        const result = yield postcss([tailwindPlugin]).process(css, { from: undefined });
-        result.css = removeDarkClassNamePrefix(result.css);
-        return result.css;
+        return removeDarkClassNamePrefix(generateUtilities(content, prefix).toString());
     });
 }
 export function getTailwindSelectors(_a) {
     return __awaiter(this, arguments, void 0, function* ({ content }) {
-        const css = `@tailwind utilities;`;
-        const tailwindPlugin = tailwindcss({
-            content: getContent(content),
-            corePlugins: { preflight: false },
-            darkMode: 'class',
-        });
-        const result = yield postcss([tailwindPlugin]).process(css, { from: undefined });
-        const selectors = getAllSelectors(result.root.nodes);
-        return selectors;
+        return getAllSelectors(generateUtilities(content, '').nodes);
     });
 }

package/dist/css/tailwindInternals.d.ts

@@ -0,0 +1,10 @@
+export type { TailwindContext } from 'tailwindcss-v3/lib/lib/setupContextUtils.js';
+export { default as resolveConfig } from 'tailwindcss-v3/resolveConfig.js';
+export declare const createContext: (config: ReturnType<typeof import("tailwindcss-v3/resolveConfig.js")>) => import("tailwindcss-v3/lib/lib/setupContextUtils.js").TailwindContext;
+export declare const generateRules: (candidates: Set<string>, context: import("tailwindcss-v3/lib/lib/setupContextUtils.js").TailwindContext) => import("tailwindcss-v3/lib/lib/setupContextUtils.js").RuleEntry[];
+export declare const defaultExtractor: (context: import("tailwindcss-v3/lib/lib/setupContextUtils.js").TailwindContext) => (content: string) => string[];
+export declare const NOT_ON_DEMAND: string;
+export declare const cloneNodes: (nodes: import("postcss/lib/node").ChildNode[], source?: unknown, raws?: {
+    layer: string;
+}) => import("postcss/lib/node").ChildNode[];
+export declare const postProcessSteps: ((context: import("tailwindcss-v3/lib/lib/setupContextUtils.js").TailwindContext) => (root: import("postcss").Root) => void)[];

package/dist/css/tailwindInternals.js

@@ -0,0 +1,28 @@
+// internals composed by processTailwindFeatures
+import collapseAdjacentRulesModule from 'tailwindcss-v3/lib/lib/collapseAdjacentRules.js';
+import collapseDuplicateDeclarationsModule from 'tailwindcss-v3/lib/lib/collapseDuplicateDeclarations.js';
+import defaultExtractorModule from 'tailwindcss-v3/lib/lib/defaultExtractor.js';
+import evaluateTailwindFunctionsModule from 'tailwindcss-v3/lib/lib/evaluateTailwindFunctions.js';
+import generateRulesModule from 'tailwindcss-v3/lib/lib/generateRules.js';
+import resolveDefaultsAtRulesModule from 'tailwindcss-v3/lib/lib/resolveDefaultsAtRules.js';
+import setupContextUtils from 'tailwindcss-v3/lib/lib/setupContextUtils.js';
+import sharedState from 'tailwindcss-v3/lib/lib/sharedState.js';
+import substituteScreenAtRulesModule from 'tailwindcss-v3/lib/lib/substituteScreenAtRules.js';
+import cloneNodesModule from 'tailwindcss-v3/lib/util/cloneNodes.js';
+export { default as resolveConfig } from 'tailwindcss-v3/resolveConfig.js';
+// node exposes these cjs internals as a namespace; bundlers and vitest unwrap default
+function unwrapDefault(mod) {
+    return typeof mod === 'function' ? mod : mod.default;
+}
+export const { createContext } = setupContextUtils;
+export const { generateRules } = generateRulesModule;
+export const { defaultExtractor } = defaultExtractorModule;
+export const { NOT_ON_DEMAND } = sharedState;
+export const cloneNodes = unwrapDefault(cloneNodesModule);
+export const postProcessSteps = [
+    unwrapDefault(evaluateTailwindFunctionsModule),
+    unwrapDefault(substituteScreenAtRulesModule),
+    unwrapDefault(resolveDefaultsAtRulesModule),
+    unwrapDefault(collapseAdjacentRulesModule),
+    unwrapDefault(collapseDuplicateDeclarationsModule),
+];

package/dist/mdx/server-only/getMdx.js

@@ -53,8 +53,13 @@ export function getMdx(_a) {
         const traceFn = trace !== null && trace !== void 0 ? trace : ((_name, fn) => fn());
         const processedContent = preprocessPageContent(content, variables);
         const processedSnippets = snippets.map((snippet) => (Object.assign(Object.assign({}, snippet), { content: preprocessCustomHeadingIds(preprocessMdxFragmentCode(replaceVariables(snippet.content, variables))) })));
-        if (!tailwindSelectors)
-            tailwindSelectors = yield traceFn('getMdx.getTailwindSelectors', () => __awaiter(this, void 0, void 0, function* () { return getTailwindSelectors({ content: processedContent }); }));
+        // selectors only feed rehypeDynamicTailwindCss, which rewrites class attributes
+        if (!tailwindSelectors) {
+            const hasClasses = [processedContent, ...processedSnippets.map(({ content }) => content)].some(hasClassAttribute);
+            tailwindSelectors = hasClasses
+                ? yield traceFn('getMdx.getTailwindSelectors', () => __awaiter(this, void 0, void 0, function* () { return getTailwindSelectors({ content: processedContent }); }))
+                : [];
+        }
         const snippetTreeMap = yield traceFn('getMdx.createSnippetTreeMap', () => __awaiter(this, void 0, void 0, function* () { return createSnippetTreeMap(processedSnippets); }));
         const mdxOptionsData = {
             subdomain,
@@ -173,6 +178,10 @@ export function getMdx(_a) {
             panelMdxSourceWithNoJs }, (parseFailed && { parseFailed }));
     });
 }
+const CLASS_ATTRIBUTE = /\bclass(?:Name)?\b/;
+function hasClassAttribute(content) {
+    return CLASS_ATTRIBUTE.test(content);
+}
 function compileMdx(_a) {
     return __awaiter(this, arguments, void 0, function* ({ content, failure, scope, mdxOptions, mdxOptionsNoJs, fallbackOptions, codeStyling, path, traceFn, customLanguages, skipNoJs, }) {
         const withJs = yield traceFn('compileMdx.withJs', () => __awaiter(this, void 0, void 0, function* () {