@styleframe/core 1.0.0 → 1.0.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @styleframe/core
 
+## 1.0.2
+
+### Patch Changes
+
+- [#35](https://github.com/styleframe-dev/styleframe/pull/35) [`5d53569`](https://github.com/styleframe-dev/styleframe/commit/5d5356960af687884703f3de5d3d1638d8ee9d8a) Thanks [@alexgrozav](https://github.com/alexgrozav)! - fix: Update published files references in package.json
+
+## 1.0.1
+
+### Patch Changes
+
+- Update README.md
+
 ## 1.0.0
 
 ### Major Changes

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Alex Grozav
+
+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/dist/styleframe.d.ts

@@ -0,0 +1,301 @@
+import { Properties } from 'csstype';
+
+export declare function applyModifiers<InstanceType extends Container>(baseInstance: InstanceType, root: Root, modifiers: Map<string, ModifierFactory>): InstanceType;
+
+export declare type AtRule = {
+    type: "at-rule";
+    identifier: string;
+    rule: string;
+    declarations: DeclarationsBlock;
+    variables: Variable[];
+    children: ContainerChild[];
+};
+
+export declare type CapitalizeFirst<T extends string> = T extends `${infer First}${infer Rest}` ? `${Uppercase<First>}${Rest}` : T;
+
+/**
+ * Capitalizes the first letter of a string
+ */
+export declare function capitalizeFirst(str: string): string;
+
+/**
+ * Deep clone a value.
+ *
+ * We're using rfdc for this, but maintaining our own implementation
+ * to avoid production dependencies on external libraries.
+ *
+ * @source https://github.com/davidmarkclements/rfdc
+ */
+declare type CloneFunction<T = any> = (obj: T) => T;
+
+export declare function combineKeys(groups: string[][]): string[][];
+
+declare type ConstructorHandler<T = any> = (obj: T, fn: CloneFunction) => T;
+
+declare type ConstructorHandlerTuple<T = any> = [
+new (...args: any[]) => T,
+ConstructorHandler<T>
+];
+
+export declare type Container = {
+    children: ContainerChild[];
+    variables: Variable[];
+    declarations: DeclarationsBlock;
+};
+
+export declare type ContainerChild = Variable | Selector | AtRule | Utility;
+
+export declare function createAtRuleFunction(parent: Container, root: Root): (identifier: string, rule: string, declarationsOrCallback?: DeclarationsBlock | DeclarationsCallback) => AtRule;
+
+export declare function createCssFunction(_parent: Container, _root: Root): (strings: TemplateStringsArray, ...interpolations: TokenValue[]) => CSS_2;
+
+export declare function createDeclarationsCallbackContext(parent: Container, root: Root): DeclarationsCallbackContext;
+
+export declare function createKeyframesFunction(parent: Container, root: Root): (name: string, declarations: Record<string, DeclarationsBlock>) => AtRule;
+
+export declare function createMediaFunction(parent: Container, root: Root): (query: string, declarationsOrCallback?: DeclarationsBlock | DeclarationsCallback) => AtRule;
+
+export declare function createModifiedUtilityInstances(baseInstance: Utility, availableModifiers: ModifierFactory[], root: Root): Utility[];
+
+export declare function createModifierFunction(_parent: Container, root: Root): <Key extends string>(key: Key | Key[], factory: ModifierFactory["factory"]) => ModifierFactory;
+
+export declare function createRecipeFunction(_parent: Container, root: Root): <Name extends string, Variants extends Record<string, Record<string, VariantDeclarationsBlock>>>(name: Name, defaults: Recipe<Name, Variants>["defaults"], variants: Recipe<Name, Variants>["variants"], options?: {
+    defaultVariants?: Recipe<Name, Variants>["defaultVariants"];
+    compoundVariants?: Recipe<Name, Variants>["compoundVariants"];
+}) => Recipe<Name, Variants>;
+
+export declare function createRefFunction(_parent: Container, _root: Root): <Name extends string>(variable: Variable<Name> | Name, fallback?: string) => Reference<Name>;
+
+export declare function createRoot(): Root;
+
+export declare function createSelectorFunction(parent: Container, root: Root): (query: string, declarationsOrCallback: DeclarationsBlock | Container | DeclarationsCallback) => Selector;
+
+export declare function createThemeFunction(_parent: Container, root: Root): (name: string, callback: DeclarationsCallback) => Theme;
+
+export declare function createUtilityFunction(parent: Container, root: Root): <Name extends string>(name: Name, factory: UtilityCallbackFn) => UtilityCreatorFn;
+
+export declare function createVariableFunction(parent: Container, _root: Root): <Name extends string>(nameOrInstance: Name | Variable<Name>, value: TokenValue, options?: {
+    default: boolean;
+}) => Variable<Name>;
+
+declare type CSS_2 = {
+    type: "css";
+    value: TokenValue[];
+};
+export { CSS_2 as CSS }
+
+declare type CSSValueWithReference<T> = T extends string | number | undefined ? T | TokenValue : T extends object ? CSSValueWithReference<T> : T | TokenValue;
+
+export declare type DeclarationsBlock = {
+    [K in keyof Properties]: CSSValueWithReference<Properties[K]>;
+} & {
+    [key: string]: CSSValueWithReference<Properties[keyof Properties]> | DeclarationsBlock;
+};
+
+export declare type DeclarationsCallback<Context extends DeclarationsCallbackContext = DeclarationsCallbackContext> = (context: Context) => DeclarationsBlock | void;
+
+export declare type DeclarationsCallbackContext = {
+    variable: ReturnType<typeof createVariableFunction>;
+    selector: ReturnType<typeof createSelectorFunction>;
+    atRule: ReturnType<typeof createAtRuleFunction>;
+    keyframes: ReturnType<typeof createKeyframesFunction>;
+    media: ReturnType<typeof createMediaFunction>;
+    ref: ReturnType<typeof createRefFunction>;
+    css: ReturnType<typeof createCssFunction>;
+};
+
+export declare const deepClone: CloneFunction<any>;
+
+export declare function getModifier(root: Root, name: string): ModifierFactory;
+
+export declare function getUtility(root: Root, name: string): UtilityFactory;
+
+export declare function getVariable(root: Container, name: string): Variable;
+
+export declare function isAtRule(value: unknown): value is AtRule;
+
+export declare function isContainer(value: unknown): value is Container;
+
+export declare function isCSS(value: unknown): value is CSS_2;
+
+export declare function isModifier(value: unknown): value is ModifierFactory;
+
+export declare function isObject(value: unknown): value is object;
+
+export declare function isPrimitiveTokenValue(value: unknown): value is PrimitiveTokenValue;
+
+export declare function isRef<Name extends string = string>(value: unknown): value is Reference<Name>;
+
+export declare function isRoot(value: unknown): value is Root;
+
+export declare function isSelector(value: unknown): value is Selector;
+
+export declare function isTheme(value: unknown): value is Theme;
+
+/**
+ * Tokens
+ */
+export declare function isToken<T>(value: unknown, type: TokenType): value is T;
+
+export declare function isTokenValue(value: unknown): value is TokenValue;
+
+export declare function isUtility<Name extends string = string>(value: unknown): value is Utility<Name>;
+
+export declare function isVariable<Name extends string = string>(value: unknown): value is Variable<Name>;
+
+export declare function merge(base: Styleframe, ...instances: Styleframe[]): Styleframe;
+
+export declare function mergeContainers<T extends Container>(a: T, b: T): T;
+
+export declare function mergeThemesArray(a: Theme[], b: Theme[]): Theme[];
+
+export declare function mergeVariablesArray(a: Variable[], b: Variable[]): Variable[];
+
+export declare type ModifierCallbackFn = DeclarationsCallback<DeclarationsCallbackContext & Pick<Utility, "declarations" | "variables" | "children">>;
+
+export declare type ModifierFactory = {
+    type: "modifier";
+    key: string[];
+    factory: ModifierCallbackFn;
+};
+
+export declare function parseDeclarationsBlock(declarations: DeclarationsBlock, context: DeclarationsCallbackContext): DeclarationsBlock;
+
+export declare type PrimitiveTokenValue = number | string | boolean | null | undefined;
+
+export declare type Recipe<Name extends string = string, Variants extends Record<string, Record<string, VariantDeclarationsBlock>> = Record<string, Record<string, VariantDeclarationsBlock>>> = {
+    type: "recipe";
+    name: Name;
+    defaults: VariantDeclarationsBlock;
+    variants: Variants;
+    defaultVariants?: {
+        [K in keyof Variants]?: keyof Variants[K] & string;
+    };
+    compoundVariants?: Array<{
+        [K in keyof Variants]?: keyof Variants[K] & string;
+    } & {
+        declarations: VariantDeclarationsBlock;
+    }>;
+};
+
+export declare type Reference<Name extends string = string> = {
+    type: "reference";
+    name: Name;
+    fallback?: TokenValue;
+};
+
+export declare function rfdc<T = any>(opts?: RfdcOptions): CloneFunction<T>;
+
+declare interface RfdcOptions {
+    circular?: boolean;
+    proto?: boolean;
+    constructorHandlers?: ConstructorHandlerTuple[];
+}
+
+export declare type Root = {
+    type: "root";
+    declarations: DeclarationsBlock;
+    utilities: UtilityFactory[];
+    modifiers: ModifierFactory[];
+    recipes: Recipe[];
+    variables: Variable[];
+    children: ContainerChild[];
+    themes: Theme[];
+};
+
+export declare type Selector = {
+    type: "selector";
+    query: string;
+    declarations: DeclarationsBlock;
+    variables: Variable[];
+    children: ContainerChild[];
+};
+
+export declare interface Styleframe {
+    root: Root;
+    variable: ReturnType<typeof createVariableFunction>;
+    selector: ReturnType<typeof createSelectorFunction>;
+    utility: ReturnType<typeof createUtilityFunction>;
+    modifier: ReturnType<typeof createModifierFunction>;
+    recipe: ReturnType<typeof createRecipeFunction>;
+    theme: ReturnType<typeof createThemeFunction>;
+    atRule: ReturnType<typeof createAtRuleFunction>;
+    keyframes: ReturnType<typeof createKeyframesFunction>;
+    media: ReturnType<typeof createMediaFunction>;
+    ref: ReturnType<typeof createRefFunction>;
+    css: ReturnType<typeof createCssFunction>;
+    options: StyleframeOptions;
+}
+
+export declare function styleframe(userOptions?: StyleframeOptions): Styleframe;
+
+export declare type StyleframeOptions = {
+    indent?: string;
+    variables?: {
+        name?: VariableNameFn;
+    };
+    utilities?: {
+        selector?: UtilitySelectorFn;
+    };
+    theme?: {
+        selector?: ThemeSelectorFn;
+    };
+};
+
+export declare type Theme = {
+    type: "theme";
+    name: string;
+    declarations: DeclarationsBlock;
+    variables: Variable[];
+    children: ContainerChild[];
+};
+
+export declare type ThemeSelectorFn = (options: {
+    name: string;
+}) => string;
+
+export declare type TokenType = Variable["type"] | Reference["type"] | Selector["type"] | AtRule["type"] | CSS_2["type"] | Utility["type"] | ModifierFactory["type"] | Recipe["type"] | Theme["type"] | Root["type"];
+
+export declare type TokenValue = PrimitiveTokenValue | Reference | CSS_2 | Array<PrimitiveTokenValue | Reference | CSS_2>;
+
+export declare type Utility<Name extends string = string> = {
+    type: "utility";
+    name: Name;
+    value: string;
+    declarations: DeclarationsBlock;
+    variables: Variable[];
+    children: ContainerChild[];
+    modifiers: string[];
+};
+
+export declare type UtilityCallbackFn = DeclarationsCallback<DeclarationsCallbackContext & {
+    value: TokenValue;
+}>;
+
+export declare type UtilityCreatorFn = (values: Record<string, TokenValue>, modifiers?: ModifierFactory[]) => void;
+
+export declare type UtilityFactory<Name extends string = string> = {
+    type: "utility";
+    name: Name;
+    factory: UtilityCallbackFn;
+};
+
+export declare type UtilitySelectorFn = (options: {
+    name: string;
+    value: string;
+    modifiers: string[];
+}) => string;
+
+export declare type Variable<Name extends string = string> = {
+    type: "variable";
+    name: Name;
+    value: TokenValue;
+};
+
+export declare type VariableNameFn = (options: {
+    name: string;
+}) => string;
+
+export declare type VariantDeclarationsBlock = Record<string, string | true>;
+
+export { }