@unocss/core 0.1.0-beta.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Anthony Fu <https://github.com/antfu>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,18 @@
+# @unocss/core
+
+The core engine of [UnoCSS](https://github.com/antfu/unocss) without any presets. Can be used as the engine of your own atomic-css framework.
+
+## Usage
+
+```ts
+import { createGenerator } from '@unocss/core'
+
+const generator = createGenerator({ /* user options */ }, { /* default options */ })
+
+const { css } = await generator.generate(code)
+```
+
+## License
+
+MIT License © 2021-PRESENT [Anthony Fu](https://github.com/antfu)
+

package/dist/index.d.ts

@@ -0,0 +1,219 @@
+declare type Awaitable<T> = T | Promise<T>;
+declare type ArgumentType<T> = T extends ((...args: infer A) => any) ? A : never;
+declare type Shift<T> = T extends [_: any, ...args: infer A] ? A : never;
+declare type RestArgs<T> = Shift<ArgumentType<T>>;
+declare type DeepPartial<T> = {
+    [P in keyof T]?: DeepPartial<T[P]>;
+};
+declare type CSSObject = Record<string, string | number | undefined>;
+declare type CSSEntries = [string, string | number | undefined][];
+declare type Extractor = (code: string, id?: string) => Awaitable<Set<string> | undefined>;
+declare type DynamicRule = [RegExp, ((match: string[], theme: Theme) => Awaitable<CSSObject | CSSEntries | undefined>)];
+declare type StaticRule = [string, CSSObject | CSSEntries];
+declare type Rule = DynamicRule | StaticRule;
+declare type DynamicShortcut = [RegExp, ((match: string[]) => (string | string[] | undefined))];
+declare type StaticShortcut = [string, string | string[]];
+declare type StaticShortcutMap = Record<string, string | string[]>;
+declare type UserShortcuts = StaticShortcutMap | (StaticShortcut | DynamicShortcut | StaticShortcutMap)[];
+declare type Shortcut = StaticShortcut | DynamicShortcut;
+declare type ExcludeRule = string | RegExp;
+declare type Variant = {
+    match: (input: string, theme: Theme) => string | undefined;
+    selector?: (input: string, theme: Theme) => string | undefined;
+    rewrite?: (input: CSSEntries, theme: Theme) => CSSEntries | undefined;
+    mediaQuery?: (selector: string, theme: Theme) => string | undefined;
+};
+interface Theme {
+    borderRadius?: Record<string, string>;
+    breakpoints?: Record<string, string>;
+    colors?: Record<string, string | Record<string, string>>;
+    fontFamily?: Record<string, string>;
+    fontSize?: Record<string, [string, string]>;
+    lineHeight?: Record<string, string>;
+    letterSpacing?: Record<string, string>;
+}
+interface ConfigBase {
+    /**
+     * Rules to generate CSS utilities
+     */
+    rules?: Rule[];
+    /**
+     * Variants that preprocess the selectors,
+     * having the ability to rewrite the CSS object.
+     */
+    variants?: Variant[];
+    /**
+     * Similar to Windi CSS's shortcuts,
+     * allows you have create new utilities by combining existing ones.
+     */
+    shortcuts?: UserShortcuts;
+    /**
+     * Rules to exclude the selectors for your design system (to narrow down the possibilities).
+     * Combining `warnExcluded` options it can also helps you identify wrong usages.
+     */
+    excluded?: ExcludeRule[];
+    /**
+     * Extractors to handle the source file and outputs possible classes/selectors
+     * Can be language-aware.
+     */
+    extractors?: Extractor[];
+    /**
+     * Theme object for shared configuration between rules
+     */
+    theme?: Theme;
+}
+interface Preset extends ConfigBase {
+    enforce?: 'pre' | 'post';
+}
+interface GeneratorOptions {
+    /**
+     * Merge utilities with the exact same body to save the file size
+     *
+     * @default true
+     */
+    mergeSelectors?: boolean;
+    /**
+     * Emit warning when excluded selectors are found
+     *
+     * @default true
+     */
+    warnExcluded?: boolean;
+}
+interface UserConfig extends ConfigBase, GeneratorOptions {
+    theme?: Theme;
+    presets?: Preset[];
+}
+interface UserConfigDefaults extends ConfigBase {
+    theme?: Theme;
+    presets?: Preset[];
+}
+interface ResolvedConfig extends Omit<Required<UserConfig>, 'presets' | 'rules' | 'shortcuts'> {
+    shortcuts: Shortcut[];
+    rulesSize: number;
+    rulesDynamic: (DynamicRule | undefined)[];
+    rulesStaticMap: Record<string, [number, CSSObject | CSSEntries] | undefined>;
+}
+interface GenerateResult {
+    css: string;
+    matched: Set<string>;
+}
+declare type VariantMatchedResult = readonly [
+    string,
+    string,
+    Variant[]
+];
+declare type ParsedUtil = readonly [
+    number,
+    string,
+    CSSEntries,
+    Variant[]
+];
+declare type StringifiedUtil = readonly [
+    number,
+    string,
+    string,
+    string | undefined
+];
+declare function defineConfig(config: UserConfig): UserConfig;
+
+declare function escapeRegExp(string: string): string;
+/**
+ * CSS Selector Escape
+ */
+declare function escapeSelector(str: string): string;
+declare const e: typeof escapeSelector;
+
+declare function entriesToCss(arr?: CSSEntries): string;
+declare function isObject(item: any): item is Record<string, any>;
+declare function mergeDeep<T>(original: T, patch: DeepPartial<T>): T;
+declare function isStaticRule(rule: Rule): rule is StaticRule;
+declare function isStaticShortcut(sc: Shortcut): sc is StaticShortcut;
+
+declare function toArray<T>(value?: T | T[]): T[];
+declare function uniq<T>(value: T[]): T[];
+declare function mergeSet<T>(target: Set<T>, append: Set<T>): Set<T>;
+
+declare const variantMatcher: (name: string) => (input: string) => string | undefined;
+
+declare function size(str: string): string | undefined;
+declare function border(str: string): string | undefined;
+declare function number(str: string): number | undefined;
+declare function percent(str: string): string | undefined;
+declare function fraction(str: string): string | undefined;
+declare function bracket(str: string): string | undefined;
+
+declare const handlers_size: typeof size;
+declare const handlers_border: typeof border;
+declare const handlers_number: typeof number;
+declare const handlers_percent: typeof percent;
+declare const handlers_fraction: typeof fraction;
+declare const handlers_bracket: typeof bracket;
+declare namespace handlers {
+  export {
+    handlers_size as size,
+    handlers_border as border,
+    handlers_number as number,
+    handlers_percent as percent,
+    handlers_fraction as fraction,
+    handlers_bracket as bracket,
+  };
+}
+
+declare type HandlerName = keyof typeof handlers;
+declare const handlersNames: ("number" | "size" | "border" | "percent" | "fraction" | "bracket")[];
+declare type Handler = {
+    [K in HandlerName]: Handler;
+} & {
+    (str: string): string | undefined;
+    __options: {
+        sequence: HandlerName[];
+    };
+};
+declare const handler: Handler;
+
+declare function hex2rgba(hex: string): [number, number, number, number] | [number, number, number] | undefined;
+
+declare function getMatchedPositions(code: string, matched: Set<string>): [number, number][];
+
+declare const attributifyRE: RegExp;
+declare const validateFilterRE: RegExp;
+declare function isAttributifySelector(selector: string): RegExpMatchArray | null;
+declare function isValidSelector(selector?: string): selector is string;
+
+declare class TwoKeyMap<K1, K2, V> {
+    _map: Map<K1, Map<K2, V>>;
+    get(key1: K1, key2: K2): V | undefined;
+    getFallback(key1: K1, key2: K2, fallback: V): V;
+    set(key1: K1, key2: K2, value: V): this;
+    has(key1: K1, key2: K2): boolean | undefined;
+    delete(key1: K1, key2: K2): boolean;
+    deleteTop(key1: K1): boolean;
+    map<T>(fn: (v: V, k1: K1, k2: K2) => T): T[];
+}
+declare class BetterMap<K, V> extends Map<K, V> {
+    map<R>(mapFn: (value: V, key: K) => R): R[];
+}
+
+declare const extractorSplit: Extractor;
+
+declare class UnoGenerator {
+    userConfig: UserConfig;
+    defaults: UserConfigDefaults;
+    private _cache;
+    config: ResolvedConfig;
+    excluded: Set<string>;
+    constructor(userConfig?: UserConfig, defaults?: UserConfigDefaults);
+    setConfig(userConfig?: UserConfig, defaults?: UserConfigDefaults): void;
+    applyExtractors(code: string, id?: string, set?: Set<string>): Promise<Set<string>>;
+    generate(input: string | Set<string>, id?: string, scope?: string): Promise<GenerateResult>;
+    matchVariants(raw: string): VariantMatchedResult;
+    applyVariants(parsed: ParsedUtil, variants?: Variant[], raw?: string): readonly [string, CSSEntries, string | undefined];
+    parseUtil(input: string | VariantMatchedResult): Promise<ParsedUtil | undefined>;
+    stringifyUtil(parsed?: ParsedUtil): StringifiedUtil | undefined;
+    expandShortcut(processed: string): string[] | undefined;
+    stringifyShortcuts(parent: VariantMatchedResult, expanded: string[]): Promise<StringifiedUtil[]>;
+    isExcluded(raw: string): boolean;
+}
+declare function createGenerator(config?: UserConfig, defaults?: UserConfigDefaults): UnoGenerator;
+
+export { ArgumentType, Awaitable, BetterMap, CSSEntries, CSSObject, ConfigBase, DeepPartial, DynamicRule, DynamicShortcut, ExcludeRule, Extractor, GenerateResult, GeneratorOptions, Handler, HandlerName, ParsedUtil, Preset, ResolvedConfig, RestArgs, Rule, Shift, Shortcut, StaticRule, StaticShortcut, StaticShortcutMap, StringifiedUtil, Theme, TwoKeyMap, UnoGenerator, UserConfig, UserConfigDefaults, UserShortcuts, Variant, VariantMatchedResult, attributifyRE, border, bracket, createGenerator, defineConfig, e, entriesToCss, escapeRegExp, escapeSelector, extractorSplit, fraction, getMatchedPositions, handler, handlersNames, hex2rgba, isAttributifySelector, isObject, isStaticRule, isStaticShortcut, isValidSelector, mergeDeep, mergeSet, number, percent, size, toArray, uniq, validateFilterRE, variantMatcher };