@master/css 2.0.0-rc.5 → 2.0.0-rc.50

package/dist/types/config.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/types/config.d.ts

@@ -0,0 +1,70 @@
+import type { PropertiesHyphen } from 'csstype';
+import type SyntaxRuleType from '../syntax-rule-type';
+import type { SyntaxRule } from '../syntax-rule';
+import type { ValueComponent } from './syntax';
+import type { rules, utilities } from '../config';
+export interface SyntaxRuleDefinition {
+    type?: SyntaxRuleType;
+    matcher?: RegExp;
+    sign?: string;
+    key?: string;
+    subkey?: string;
+    ambiguousKeys?: string[];
+    ambiguousValues?: (RegExp | string)[];
+    variables?: string[];
+    separators?: string[];
+    unit?: any;
+    declarations?: PropertiesHyphen;
+    includeAnimations?: boolean;
+    analyze?: (this: SyntaxRule, className: string) => [valueToken: string, prefixToken?: string];
+    transformValue?(this: SyntaxRule, value: string): string;
+    transformValueComponents?(this: SyntaxRule, valueComponents: ValueComponent[]): ValueComponent[];
+    declare?(this: SyntaxRule, value: string, valueComponents: ValueComponent[]): PropertiesHyphen;
+    delete?(this: SyntaxRule, className: string): void;
+    create?(this: SyntaxRule, className: string): void;
+    insert?(this: SyntaxRule): void;
+}
+export type VariableValue = number | string | false | (number | string)[];
+export type VariableDefinition = {
+    [key in '' | `@${string}` | string]?: VariableValue | VariableDefinition;
+} | VariableValue;
+export type CSSKeyframes = Record<'from' | 'to' | string, PropertiesHyphen>;
+export type AnimationDefinitions = Record<string, CSSKeyframes>;
+export type SelectorDefinitions = Record<string, string | string[]>;
+export interface AtDefinitions {
+    [key: string]: number | string | AtDefinitions;
+}
+export interface StyleDefinitions {
+    [key: string]: string | StyleDefinitions;
+}
+export type SyntaxRuleDefinitions = Partial<Record<keyof typeof rules | string, SyntaxRuleDefinition>>;
+export type VariableDefinitions = {
+    [key in keyof typeof rules]?: VariableDefinition;
+} & Record<string, VariableDefinition>;
+export type UtilityDefinitions = {
+    [key in keyof typeof utilities]?: PropertiesHyphen;
+} & Record<string, PropertiesHyphen>;
+export type ModeDefinitions = Record<string, 'class' | 'media' | 'host' | false>;
+export interface FunctionDefinition {
+    unit?: string;
+    transform?(this: SyntaxRule, value: string, bypassVariableNames: string[]): string | ValueComponent[];
+}
+export type FunctionDefinitions = Record<string, FunctionDefinition>;
+export interface Config {
+    extends?: (Config | any)[];
+    components?: StyleDefinitions;
+    at?: AtDefinitions;
+    selectors?: SelectorDefinitions;
+    utilities?: UtilityDefinitions;
+    variables?: VariableDefinitions;
+    rules?: SyntaxRuleDefinitions;
+    rootSize?: number;
+    baseUnit?: number;
+    defaultMode?: 'light' | 'dark' | string | false;
+    scope?: string;
+    important?: boolean;
+    override?: boolean;
+    functions?: FunctionDefinitions;
+    animations?: AnimationDefinitions;
+    modes?: ModeDefinitions;
+}

package/dist/types/config.mjs

@@ -0,0 +1 @@
+

package/dist/types/global.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/types/global.d.ts

@@ -1,5 +1,5 @@
-import type { MasterCSS as _MasterCSS } from '../core';
+import type Core from '../core';
 declare global {
-    var MasterCSS: typeof _MasterCSS;
-    var masterCSSs: _MasterCSS[];
+    var masterCSSs: Core[];
+    var MasterCSS: typeof Core;
 }

package/dist/types/global.mjs

@@ -0,0 +1 @@
+

package/dist/types/syntax.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/types/syntax.d.ts

@@ -0,0 +1,106 @@
+import { SyntaxRuleDefinition } from './config';
+export type AtComponent = AtArbitraryComponent | AtFeatureComponent | AtOperatorComponent;
+export interface AtArbitraryComponent {
+    type: 'arbitrary';
+    token?: string;
+    value: string;
+}
+export interface AtFeatureComponent {
+    type: 'feature';
+    token?: string;
+    name: string;
+    valueType: 'number' | 'string';
+    value: string | number;
+    unit?: string;
+}
+export interface AtOperatorComponent {
+    type: 'operator';
+    token: '&';
+    value: 'and';
+}
+export type ValueComponent = StringValueComponent | NumericValueComponent | FunctionValueComponent | VariableValueComponent | SeparatorValueComponent;
+export interface StringValueComponent {
+    text?: string;
+    token: string;
+    type: 'string';
+    value: string;
+}
+export interface NumericValueComponent {
+    text?: string;
+    token: string;
+    type: 'number';
+    value: number;
+    unit?: string;
+}
+export interface FunctionValueComponent {
+    text?: string;
+    token: string;
+    type: 'function';
+    name: string;
+    symbol: string;
+    children: ValueComponent[];
+    bypassTransform?: boolean;
+}
+export interface VariableValueComponent {
+    text?: string;
+    token: string;
+    type: 'variable';
+    name: string;
+    alpha?: string;
+    fallback?: string;
+    variable?: Variable;
+}
+export interface SeparatorValueComponent {
+    text?: string;
+    token: string;
+    type: 'separator';
+    value: string;
+}
+export interface DefinedRule {
+    id: string;
+    key?: string;
+    keys: string[];
+    matchers: {
+        key?: RegExp;
+        variable?: RegExp;
+        value?: RegExp;
+        arbitrary?: RegExp;
+    };
+    variables: Record<string, Variable>;
+    order: number;
+    definition: SyntaxRuleDefinition;
+}
+export type MediaFeatureComponent = {
+    type: string;
+    tokenType?: string;
+    operator?: string;
+    value: number;
+    unit: string;
+};
+export interface MediaQuery {
+    token: string;
+    features: Record<string, MediaFeatureComponent>;
+    type?: string;
+}
+type VariableCommon = {
+    group?: string;
+    name: string;
+    key: string;
+    modes?: Record<string, TypeVariable>;
+};
+export interface StringVariable {
+    type: 'string';
+    value: string;
+}
+export interface NumberVariable {
+    type: 'number';
+    value: number;
+}
+export interface ColorVariable {
+    type: 'color';
+    value: string;
+    space: 'rgb' | 'hsl';
+}
+export type TypeVariable = StringVariable | NumberVariable | ColorVariable;
+export type Variable = TypeVariable & VariableCommon;
+export {};

package/dist/types/syntax.mjs

@@ -0,0 +1 @@
+

package/dist/utils/are-rule-at-equal.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+function areRuleAtEqual(aSyntaxRule, bSyntaxRule) {
+    const aQueryTypes = Object.keys(aSyntaxRule.at);
+    const bQueryTypes = Object.keys(bSyntaxRule.at);
+    if (aQueryTypes.length !== bQueryTypes.length) {
+        return false;
+    }
+    for (const aQueryType of aQueryTypes){
+        const aAtComponents = aSyntaxRule.at[aQueryType];
+        const bAtComponents = bSyntaxRule.at[aQueryType];
+        for (const aAtComponent of aAtComponents){
+            const aAtComponentToken = aSyntaxRule.resolveAtComponent(aAtComponent);
+            if (!bAtComponents.find((bAtComponent)=>bSyntaxRule.resolveAtComponent(bAtComponent) === aAtComponentToken)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+module.exports = areRuleAtEqual;

package/dist/utils/are-rule-at-equal.d.ts

@@ -0,0 +1,2 @@
+import type { SyntaxRule } from '../syntax-rule';
+export default function areRuleAtEqual(aSyntaxRule: SyntaxRule, bSyntaxRule: SyntaxRule): boolean;

package/dist/utils/are-rule-at-equal.mjs

@@ -0,0 +1,20 @@
+function areRuleAtEqual(aSyntaxRule, bSyntaxRule) {
+    const aQueryTypes = Object.keys(aSyntaxRule.at);
+    const bQueryTypes = Object.keys(bSyntaxRule.at);
+    if (aQueryTypes.length !== bQueryTypes.length) {
+        return false;
+    }
+    for (const aQueryType of aQueryTypes){
+        const aAtComponents = aSyntaxRule.at[aQueryType];
+        const bAtComponents = bSyntaxRule.at[aQueryType];
+        for (const aAtComponent of aAtComponents){
+            const aAtComponentToken = aSyntaxRule.resolveAtComponent(aAtComponent);
+            if (!bAtComponents.find((bAtComponent)=>bSyntaxRule.resolveAtComponent(bAtComponent) === aAtComponentToken)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+export { areRuleAtEqual as default };

package/dist/utils/are-rule-modes-equal.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+function areRuleModesEqual(aSyntaxRule, bSyntaxRule) {
+    return aSyntaxRule.mode === bSyntaxRule.mode;
+}
+
+module.exports = areRuleModesEqual;

package/dist/utils/are-rule-modes-equal.d.ts

@@ -0,0 +1,2 @@
+import type { SyntaxRule } from '../syntax-rule';
+export default function areRuleModesEqual(aSyntaxRule: SyntaxRule, bSyntaxRule: SyntaxRule): boolean;

package/dist/utils/are-rule-modes-equal.mjs

@@ -0,0 +1,5 @@
+function areRuleModesEqual(aSyntaxRule, bSyntaxRule) {
+    return aSyntaxRule.mode === bSyntaxRule.mode;
+}
+
+export { areRuleModesEqual as default };

package/dist/utils/are-rule-selectors-equal.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+function areRuleSelectorsEqual(aSyntaxRule, bSyntaxRule) {
+    // suffix
+    const aVendorSuffixSelectorKeys = Object.keys(aSyntaxRule.vendorSuffixSelectors);
+    const bVendorSuffixSelectorKeys = Object.keys(bSyntaxRule.vendorSuffixSelectors);
+    if (aVendorSuffixSelectorKeys.length !== bVendorSuffixSelectorKeys.length) return false;
+    const isSameVendorSuffixSelectors = aVendorSuffixSelectorKeys.every((eachAKey)=>{
+        if (!Object.prototype.hasOwnProperty.call(bSyntaxRule.vendorSuffixSelectors, eachAKey)) return false;
+        const aValues = aSyntaxRule.vendorSuffixSelectors[eachAKey];
+        const bValues = bSyntaxRule.vendorSuffixSelectors[eachAKey];
+        return aValues.length === bValues.length && aValues.every((eachAValue)=>bValues.includes(eachAValue));
+    });
+    if (!isSameVendorSuffixSelectors) return false;
+    // prefix
+    const aVendorPrefixSelectorKeys = Object.keys(aSyntaxRule.vendorPrefixSelectors);
+    const bVendorPrefixSelectorKeys = Object.keys(bSyntaxRule.vendorPrefixSelectors);
+    if (aVendorPrefixSelectorKeys.length !== bVendorPrefixSelectorKeys.length) return false;
+    const isSameVendorPrefixSelectors = aVendorPrefixSelectorKeys.every((eachAKey)=>{
+        if (!Object.prototype.hasOwnProperty.call(bSyntaxRule.vendorPrefixSelectors, eachAKey)) return false;
+        const aValues = aSyntaxRule.vendorPrefixSelectors[eachAKey];
+        const bValues = bSyntaxRule.vendorPrefixSelectors[eachAKey];
+        return aValues.length === bValues.length && aValues.every((eachAValue)=>bValues.includes(eachAValue));
+    });
+    if (!isSameVendorPrefixSelectors) return false;
+    return true;
+}
+
+module.exports = areRuleSelectorsEqual;

package/dist/utils/are-rule-selectors-equal.d.ts

@@ -0,0 +1,2 @@
+import type { SyntaxRule } from '../syntax-rule';
+export default function areRuleSelectorsEqual(aSyntaxRule: SyntaxRule, bSyntaxRule: SyntaxRule): boolean;

package/dist/utils/are-rule-selectors-equal.mjs

@@ -0,0 +1,27 @@
+function areRuleSelectorsEqual(aSyntaxRule, bSyntaxRule) {
+    // suffix
+    const aVendorSuffixSelectorKeys = Object.keys(aSyntaxRule.vendorSuffixSelectors);
+    const bVendorSuffixSelectorKeys = Object.keys(bSyntaxRule.vendorSuffixSelectors);
+    if (aVendorSuffixSelectorKeys.length !== bVendorSuffixSelectorKeys.length) return false;
+    const isSameVendorSuffixSelectors = aVendorSuffixSelectorKeys.every((eachAKey)=>{
+        if (!Object.prototype.hasOwnProperty.call(bSyntaxRule.vendorSuffixSelectors, eachAKey)) return false;
+        const aValues = aSyntaxRule.vendorSuffixSelectors[eachAKey];
+        const bValues = bSyntaxRule.vendorSuffixSelectors[eachAKey];
+        return aValues.length === bValues.length && aValues.every((eachAValue)=>bValues.includes(eachAValue));
+    });
+    if (!isSameVendorSuffixSelectors) return false;
+    // prefix
+    const aVendorPrefixSelectorKeys = Object.keys(aSyntaxRule.vendorPrefixSelectors);
+    const bVendorPrefixSelectorKeys = Object.keys(bSyntaxRule.vendorPrefixSelectors);
+    if (aVendorPrefixSelectorKeys.length !== bVendorPrefixSelectorKeys.length) return false;
+    const isSameVendorPrefixSelectors = aVendorPrefixSelectorKeys.every((eachAKey)=>{
+        if (!Object.prototype.hasOwnProperty.call(bSyntaxRule.vendorPrefixSelectors, eachAKey)) return false;
+        const aValues = aSyntaxRule.vendorPrefixSelectors[eachAKey];
+        const bValues = bSyntaxRule.vendorPrefixSelectors[eachAKey];
+        return aValues.length === bValues.length && aValues.every((eachAValue)=>bValues.includes(eachAValue));
+    });
+    if (!isSameVendorPrefixSelectors) return false;
+    return true;
+}
+
+export { areRuleSelectorsEqual as default };

package/dist/utils/are-rule-states-equal.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var areRuleSelectorsEqual = require('./are-rule-selectors-equal.cjs');
+var areRuleModesEqual = require('./are-rule-modes-equal.cjs');
+var areRuleAtEqual = require('./are-rule-at-equal.cjs');
+
+function areRuleStatesEqual(aSyntaxRule, bSyntaxRule) {
+    return areRuleSelectorsEqual(aSyntaxRule, bSyntaxRule) && areRuleModesEqual(aSyntaxRule, bSyntaxRule) && areRuleAtEqual(aSyntaxRule, bSyntaxRule);
+}
+
+module.exports = areRuleStatesEqual;

package/dist/utils/are-rule-states-equal.d.ts

@@ -0,0 +1,2 @@
+import type { SyntaxRule } from '../syntax-rule';
+export default function areRuleStatesEqual(aSyntaxRule: SyntaxRule, bSyntaxRule: SyntaxRule): boolean;

package/dist/utils/are-rule-states-equal.mjs

@@ -0,0 +1,9 @@
+import areRuleSelectorsEqual from './are-rule-selectors-equal.mjs';
+import areRuleModesEqual from './are-rule-modes-equal.mjs';
+import areRuleAtEqual from './are-rule-at-equal.mjs';
+
+function areRuleStatesEqual(aSyntaxRule, bSyntaxRule) {
+    return areRuleSelectorsEqual(aSyntaxRule, bSyntaxRule) && areRuleModesEqual(aSyntaxRule, bSyntaxRule) && areRuleAtEqual(aSyntaxRule, bSyntaxRule);
+}
+
+export { areRuleStatesEqual as default };

package/dist/utils/are-rules-duplicated.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+function areRulesDuplicated(aSyntaxRule, bSyntaxRule) {
+    const aKeys = Object.keys(aSyntaxRule.declarations || {});
+    const bKeys = Object.keys(bSyntaxRule.declarations || {});
+    if (aKeys.length !== bKeys.length) {
+        return false;
+    }
+    for (const key of aKeys){
+        if (!Object.prototype.hasOwnProperty.call(bSyntaxRule.declarations, key)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+module.exports = areRulesDuplicated;

package/dist/utils/are-rules-duplicated.d.ts

@@ -0,0 +1,2 @@
+import { SyntaxRule } from '../syntax-rule';
+export default function areRulesDuplicated(aSyntaxRule: SyntaxRule, bSyntaxRule: SyntaxRule): boolean;

package/dist/utils/are-rules-duplicated.mjs

@@ -0,0 +1,15 @@
+function areRulesDuplicated(aSyntaxRule, bSyntaxRule) {
+    const aKeys = Object.keys(aSyntaxRule.declarations || {});
+    const bKeys = Object.keys(bSyntaxRule.declarations || {});
+    if (aKeys.length !== bKeys.length) {
+        return false;
+    }
+    for (const key of aKeys){
+        if (!Object.prototype.hasOwnProperty.call(bSyntaxRule.declarations, key)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+export { areRulesDuplicated as default };

package/dist/utils/autofill-solid-style.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+var common = require('../common.cjs');
+
+const autofillSolidStyle = function(valueComponents) {
+    if (valueComponents.length < 2) return valueComponents;
+    let styleIncluded = false;
+    let varIncluded = false;
+    for (const valueComponent of valueComponents){
+        if (valueComponent.type === 'string' && common.BORDER_STYLE_VALUES.includes(valueComponent.value) || valueComponent.type === 'variable' && common.BORDER_STYLE_VALUES.includes(String(valueComponent.variable?.value))) {
+            styleIncluded = true;
+        }
+        if (valueComponent.type === 'function' && valueComponent.name === 'var') {
+            varIncluded = true;
+        }
+    }
+    if (!styleIncluded && !varIncluded) {
+        valueComponents.push({
+            type: 'separator',
+            value: ' ',
+            token: '|'
+        }, {
+            type: 'string',
+            value: 'solid',
+            token: 'solid'
+        });
+    }
+    return valueComponents;
+};
+
+module.exports = autofillSolidStyle;

package/dist/utils/autofill-solid-style.d.ts

@@ -0,0 +1,3 @@
+import { SyntaxRuleDefinition } from '../types/config';
+declare const autofillSolidStyle: SyntaxRuleDefinition['transformValueComponents'];
+export default autofillSolidStyle;

package/dist/utils/autofill-solid-style.mjs

@@ -0,0 +1,29 @@
+import { BORDER_STYLE_VALUES } from '../common.mjs';
+
+const autofillSolidStyle = function(valueComponents) {
+    if (valueComponents.length < 2) return valueComponents;
+    let styleIncluded = false;
+    let varIncluded = false;
+    for (const valueComponent of valueComponents){
+        if (valueComponent.type === 'string' && BORDER_STYLE_VALUES.includes(valueComponent.value) || valueComponent.type === 'variable' && BORDER_STYLE_VALUES.includes(String(valueComponent.variable?.value))) {
+            styleIncluded = true;
+        }
+        if (valueComponent.type === 'function' && valueComponent.name === 'var') {
+            varIncluded = true;
+        }
+    }
+    if (!styleIncluded && !varIncluded) {
+        valueComponents.push({
+            type: 'separator',
+            value: ' ',
+            token: '|'
+        }, {
+            type: 'string',
+            value: 'solid',
+            token: 'solid'
+        });
+    }
+    return valueComponents;
+};
+
+export { autofillSolidStyle as default };

package/dist/utils/extend-config.cjs

@@ -0,0 +1,73 @@
+'use strict';
+
+var extend = require('@techor/extend');
+
+// todo: split resolveConfig into a function
+function extendConfig(...configs) {
+    const formatConfig = (config)=>{
+        const clonedConfig = extend({}, config);
+        const formatDeeply = (obj)=>{
+            for(const key in obj){
+                const value = obj[key];
+                if (typeof value === 'object' && !Array.isArray(value)) {
+                    formatDeeply(value);
+                } else if (key && !key.startsWith('@')) {
+                    obj[key] = {
+                        '': value
+                    };
+                }
+            }
+        };
+        if (clonedConfig.components) {
+            formatDeeply(clonedConfig.components);
+        }
+        if (clonedConfig.at) {
+            formatDeeply(clonedConfig.at);
+        }
+        if (clonedConfig.variables) {
+            formatDeeply(clonedConfig.variables);
+        }
+        return clonedConfig;
+    };
+    const formattedConfigs = [];
+    for (const eachConfig of configs){
+        if (!eachConfig) continue;
+        (function getConfigsDeeply(config) {
+            if (config.extends?.length) {
+                for (const eachExtend of config.extends){
+                    getConfigsDeeply('config' in eachExtend ? eachExtend.config : eachExtend);
+                }
+            }
+            formattedConfigs.push(formatConfig(config));
+        })(eachConfig);
+    }
+    let extendedConfig = {
+        animations: {},
+        components: {},
+        at: {},
+        variables: {}
+    };
+    for (const currentFormattedConfig of formattedConfigs){
+        for(const key in currentFormattedConfig){
+            switch(key){
+                case 'animations':
+                    if (currentFormattedConfig.animations) {
+                        Object.assign(extendedConfig.animations, currentFormattedConfig.animations);
+                    }
+                    break;
+                default:
+                    if (currentFormattedConfig[key]) {
+                        extendedConfig = extend(extendedConfig, {
+                            [key]: currentFormattedConfig[key]
+                        });
+                    }
+            }
+        // if (Object.prototype.hasOwnProperty.call(currentFormattedConfig.components, key)) {
+        //     Object.assign(extendedConfig.components[key], currentFormattedConfig.components[key])
+        // }
+        }
+    }
+    return extendedConfig;
+}
+
+module.exports = extendConfig;

package/dist/utils/extend-config.d.ts

@@ -1,2 +1,2 @@
-import type { Config } from '../config';
-export declare function extendConfig(...configs: Config[]): Config;
+import type { Config } from '../types/config';
+export default function extendConfig(...configs: (Config | undefined)[]): Config;

package/dist/utils/extend-config.mjs

@@ -0,0 +1,71 @@
+import extend from '@techor/extend';
+
+// todo: split resolveConfig into a function
+function extendConfig(...configs) {
+    const formatConfig = (config)=>{
+        const clonedConfig = extend({}, config);
+        const formatDeeply = (obj)=>{
+            for(const key in obj){
+                const value = obj[key];
+                if (typeof value === 'object' && !Array.isArray(value)) {
+                    formatDeeply(value);
+                } else if (key && !key.startsWith('@')) {
+                    obj[key] = {
+                        '': value
+                    };
+                }
+            }
+        };
+        if (clonedConfig.components) {
+            formatDeeply(clonedConfig.components);
+        }
+        if (clonedConfig.at) {
+            formatDeeply(clonedConfig.at);
+        }
+        if (clonedConfig.variables) {
+            formatDeeply(clonedConfig.variables);
+        }
+        return clonedConfig;
+    };
+    const formattedConfigs = [];
+    for (const eachConfig of configs){
+        if (!eachConfig) continue;
+        (function getConfigsDeeply(config) {
+            if (config.extends?.length) {
+                for (const eachExtend of config.extends){
+                    getConfigsDeeply('config' in eachExtend ? eachExtend.config : eachExtend);
+                }
+            }
+            formattedConfigs.push(formatConfig(config));
+        })(eachConfig);
+    }
+    let extendedConfig = {
+        animations: {},
+        components: {},
+        at: {},
+        variables: {}
+    };
+    for (const currentFormattedConfig of formattedConfigs){
+        for(const key in currentFormattedConfig){
+            switch(key){
+                case 'animations':
+                    if (currentFormattedConfig.animations) {
+                        Object.assign(extendedConfig.animations, currentFormattedConfig.animations);
+                    }
+                    break;
+                default:
+                    if (currentFormattedConfig[key]) {
+                        extendedConfig = extend(extendedConfig, {
+                            [key]: currentFormattedConfig[key]
+                        });
+                    }
+            }
+        // if (Object.prototype.hasOwnProperty.call(currentFormattedConfig.components, key)) {
+        //     Object.assign(extendedConfig.components[key], currentFormattedConfig.components[key])
+        // }
+        }
+    }
+    return extendedConfig;
+}
+
+export { extendConfig as default };

package/dist/utils/flatten-object.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+function flattenObject(obj, parentKey = '') {
+    return Object.entries(obj).reduce((acc, [key, value])=>{
+        const currentKey = parentKey ? `${parentKey}${key ? '-' + key : ''}` : key;
+        if (typeof value === 'object' && !Array.isArray(value)) {
+            Object.assign(acc, flattenObject(value, currentKey));
+        } else {
+            acc[currentKey] = value;
+        }
+        return acc;
+    }, {});
+}
+
+exports.flattenObject = flattenObject;

package/dist/utils/flatten-object.mjs

@@ -0,0 +1,13 @@
+function flattenObject(obj, parentKey = '') {
+    return Object.entries(obj).reduce((acc, [key, value])=>{
+        const currentKey = parentKey ? `${parentKey}${key ? '-' + key : ''}` : key;
+        if (typeof value === 'object' && !Array.isArray(value)) {
+            Object.assign(acc, flattenObject(value, currentKey));
+        } else {
+            acc[currentKey] = value;
+        }
+        return acc;
+    }, {});
+}
+
+export { flattenObject };