@hanzo/ui 5.3.36 → 5.3.39

package/dist/tailwind/typo-plugin/index.js

@@ -1,102 +0,0 @@
-import plugin from 'tailwindcss/plugin';
-import merge from 'lodash.merge';
-import castArray from 'lodash.castarray';
-import getStyles from './get-plugin-styles';
-import { commonTrailingPseudos } from './utils';
-let baseFontSize = 16;
-const computed = {
-// Reserved for future "magic properties", for example:
-// bulletColor: (color) => ({ 'ul > li::before': { backgroundColor: color } }),
-};
-function inWhere(selector, { className, modifier, prefix }) {
-    let prefixedNot = prefix(`.not-${className}`).slice(1);
-    let selectorPrefix = selector.startsWith('>')
-        ? `${modifier === 'DEFAULT' ? `.${className}` : `.${className}-${modifier}`} `
-        : '';
-    // Parse the selector, if every component ends in the same pseudo element(s) then move it to the end
-    let [trailingPseudo, rebuiltSelector] = commonTrailingPseudos(selector);
-    if (trailingPseudo) {
-        return `:where(${selectorPrefix}${rebuiltSelector}):not(:where([class~="${prefixedNot}"],[class~="${prefixedNot}"] *))${trailingPseudo}`;
-    }
-    return `:where(${selectorPrefix}${selector}):not(:where([class~="${prefixedNot}"],[class~="${prefixedNot}"] *))`;
-}
-function isObject(value) {
-    return typeof value === 'object' && value !== null;
-}
-function configToCss(config = {}, { target, className, modifier, prefix }) {
-    function updateSelector(k, v) {
-        if (target === 'legacy') {
-            return [k, v];
-        }
-        if (Array.isArray(v)) {
-            return [k, v];
-        }
-        if (isObject(v)) {
-            let nested = Object.values(v).some(isObject);
-            if (nested) {
-                return [
-                    inWhere(k, { className, modifier, prefix }),
-                    v,
-                    Object.fromEntries(Object.entries(v).map(([k, v]) => updateSelector(k, v))),
-                ];
-            }
-            return [inWhere(k, { className, modifier, prefix }), v];
-        }
-        return [k, v];
-    }
-    return Object.fromEntries(Object.entries(merge({}, ...Object.keys(config)
-        .filter((key) => computed[key])
-        .map((key) => computed[key](config[key])), ...castArray(config.css || {}))).map(([k, v]) => updateSelector(k, v)));
-}
-export default plugin.withOptions(({ className = 'prose', target = 'modern', base = 16 } = {}) => {
-    baseFontSize = base;
-    return function ({ addVariant, addComponents, theme, prefix }) {
-        let modifiers = theme('typography');
-        let options = { className, prefix };
-        for (let [name, ...selectors] of [
-            ['headings', 'h1', 'h2', 'h3', /* 'h4', 'h5', 'h6', 'th' */],
-            ['h1'],
-            ['h2'],
-            ['h3'],
-            ['h4'],
-            ['h5'],
-            ['h6'],
-            ['p'],
-            ['a'],
-            ['blockquote'],
-            ['figure'],
-            ['figcaption'],
-            ['strong'],
-            ['em'],
-            ['code'],
-            ['pre'],
-            ['ol'],
-            ['ul'],
-            ['li'],
-            ['table'],
-            ['thead'],
-            ['tr'],
-            ['th'],
-            ['td'],
-            ['img'],
-            ['video'],
-            ['hr'],
-        ]) {
-            selectors = selectors.length === 0 ? [name] : selectors;
-            let selector = target === 'legacy' ? selectors.map((selector) => `& ${selector}`) : selectors.join(', ');
-            addVariant(`${className}-${name}`, target === 'legacy' ? selector : `& :is(${inWhere(selector, options)})`);
-        }
-        addComponents(Object.keys(modifiers).map((modifier) => ({
-            [modifier === 'DEFAULT' ? `.${className}` : `.${className}-${modifier}`]: configToCss(modifiers[modifier], {
-                target,
-                className,
-                modifier,
-                prefix,
-            }),
-        })));
-    };
-}, () => {
-    return {
-        theme: { typography: getStyles(baseFontSize) },
-    };
-});

package/dist/tailwind/typo-plugin/utils.d.ts

@@ -1,6 +0,0 @@
-export function isUsableColor(color: any, values: any): any;
-/**
- * @param {string} selector
- */
-export function commonTrailingPseudos(selector: string): (string | null)[];
-//# sourceMappingURL=utils.d.ts.map

package/dist/tailwind/typo-plugin/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../tailwind/typo-plugin/utils.js"],"names":[],"mappings":"AAKA,4DAEC;AAED;;GAEG;AACH,gDAFW,MAAM,qBAiDhB"}

package/dist/tailwind/typo-plugin/utils.js

@@ -1,47 +0,0 @@
-import isPlainObject from 'lodash.isplainobject';
-import parser from 'postcss-selector-parser';
-const parseSelector = parser();
-export function isUsableColor(color, values) {
-    return isPlainObject(values) && color !== 'gray' && values[600];
-}
-/**
- * @param {string} selector
- */
-export function commonTrailingPseudos(selector) {
-    let ast = parseSelector.astSync(selector);
-    /** @type {import('postcss-selector-parser').Pseudo[][]} */
-    let matrix = [];
-    // Put the pseudo elements in reverse order in a sparse, column-major 2D array
-    for (let [i, sel] of ast.nodes.entries()) {
-        for (const [j, child] of [...sel.nodes].reverse().entries()) {
-            // We only care about pseudo elements
-            if (child.type !== 'pseudo' || !child.value.startsWith('::')) {
-                break;
-            }
-            matrix[j] = matrix[j] || [];
-            matrix[j][i] = child;
-        }
-    }
-    let trailingPseudos = parser.selector();
-    // At this point the pseudo elements are in a column-major 2D array
-    // This means each row contains one "column" of pseudo elements from each selector
-    // We can compare all the pseudo elements in a row to see if they are the same
-    for (const pseudos of matrix) {
-        // It's a sparse 2D array so there are going to be holes in the rows
-        // We skip those
-        if (!pseudos) {
-            continue;
-        }
-        let values = new Set([...pseudos.map((p) => p.value)]);
-        // The pseudo elements are not the same
-        if (values.size > 1) {
-            break;
-        }
-        pseudos.forEach((pseudo) => pseudo.remove());
-        trailingPseudos.prepend(pseudos[0]);
-    }
-    if (trailingPseudos.nodes.length) {
-        return [trailingPseudos.toString(), ast.toString()];
-    }
-    return [null, selector];
-}