@seyuna/postcss 1.0.0-canary.23 → 1.0.0-canary.25

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [1.0.0-canary.25](https://github.com/seyuna-corp/seyuna-postcss/compare/v1.0.0-canary.24...v1.0.0-canary.25) (2026-01-10)
+
+
+### Bug Fixes
+
+* resolve deadlock by correctly passing Result object for warnings ([f7766a0](https://github.com/seyuna-corp/seyuna-postcss/commit/f7766a0f3914c19368aa2a73dfca4b2217a47072))
+
+# [1.0.0-canary.24](https://github.com/seyuna-corp/seyuna-postcss/compare/v1.0.0-canary.23...v1.0.0-canary.24) (2026-01-10)
+
+
+### Bug Fixes
+
+* resolve deadlock by preventing infinite loop and using deep imports ([b7b552c](https://github.com/seyuna-corp/seyuna-postcss/commit/b7b552cfc52c88e07d12022f27269fee16ccb013))
+
 # [1.0.0-canary.23](https://github.com/seyuna-corp/seyuna-postcss/compare/v1.0.0-canary.22...v1.0.0-canary.23) (2026-01-10)
 
 

package/dist/at-rules/color-scheme.d.ts

@@ -1,4 +1,3 @@
-import type { AtRule } from "postcss";
 import { PluginContext } from "../types.js";
-export declare const light: (atRule: AtRule, context: PluginContext) => void;
-export declare const dark: (atRule: AtRule, context: PluginContext) => void;
+export declare const light: (atRule: any, context: PluginContext) => void;
+export declare const dark: (atRule: any, context: PluginContext) => void;

package/dist/at-rules/color-scheme.js

@@ -1,4 +1,5 @@
-import postcss from "postcss";
+import Rule from "postcss/lib/rule";
+import AtRule from "postcss/lib/at-rule";
 /**
  * Custom PostCSS plugin handler factory for `@light` and `@dark` at-rules.
  */
@@ -14,7 +15,7 @@ function createColorSchemeHandler(scheme) {
         /**
          * Rule 1: [data-mode="scheme"] & { ... } (Explicit mode)
          */
-        const explicitRule = new postcss.Rule({
+        const explicitRule = new Rule({
             selector: `[${modeAttribute}="${scheme}"] &`,
             source: atRule.source,
         });
@@ -22,12 +23,12 @@ function createColorSchemeHandler(scheme) {
         /**
          * Rule 2: @media (prefers-color-scheme: scheme) { [data-mode="system"] & { ... } } (System preference)
          */
-        const mediaAtRule = new postcss.AtRule({
+        const mediaAtRule = new AtRule({
             name: "media",
             params: `(prefers-color-scheme: ${scheme})`,
             source: atRule.source,
         });
-        const systemRule = new postcss.Rule({
+        const systemRule = new Rule({
             selector: `[${modeAttribute}="system"] &`,
             source: atRule.source,
         });

package/dist/at-rules/color.d.ts

@@ -1,10 +1,9 @@
-import type { AtRule } from "postcss";
 import { PluginContext } from "../types.js";
 /**
  * Handler for @each-standard-color
  */
-export declare function eachStandardColor(atRule: AtRule, context: PluginContext): void;
+export declare function eachStandardColor(atRule: any, context: PluginContext): void;
 /**
  * Handler for @each-fixed-color
  */
-export declare function eachFixedColor(atRule: AtRule, context: PluginContext): void;
+export declare function eachFixedColor(atRule: any, context: PluginContext): void;

package/dist/at-rules/container.d.ts

@@ -1,4 +1,3 @@
-import type { AtRule } from "postcss";
 import { PluginContext } from "../types.js";
 /**
  * Custom PostCSS plugin handler for responsive at-rules.
@@ -16,4 +15,4 @@ import { PluginContext } from "../types.js";
  *   }
  *
  */
-export default function container(atRule: AtRule, context: PluginContext): void;
+export default function container(atRule: any, context: PluginContext): void;

package/dist/at-rules/container.js

@@ -1,4 +1,4 @@
-import postcss from "postcss";
+import AtRule from "postcss/lib/at-rule";
 /**
  * Custom PostCSS plugin handler for responsive at-rules.
  *
@@ -37,7 +37,7 @@ export default function container(atRule, context) {
         atRule.each((node) => {
             clonedNodes.push(node.clone());
         });
-        const containerAtRule = new postcss.AtRule({
+        const containerAtRule = new AtRule({
             name: "container",
             params: `(min-width: ${minWidth})`,
             source: atRule.source,

package/dist/at-rules/index.d.ts

@@ -1,7 +1,6 @@
-import type { AtRule } from "postcss";
 import { PluginContext } from "../types.js";
 export interface AtRuleHandler {
     name: string;
-    handler: (atRule: AtRule, context: PluginContext) => void;
+    handler: (atRule: any, context: PluginContext) => void;
 }
 export declare const atRuleHandlers: AtRuleHandler[];

package/dist/at-rules/index.js

@@ -1,3 +1,4 @@
+// import type { AtRule } from "postcss";
 import { eachStandardColor, eachFixedColor } from "./color.js";
 import container from "./container.js";
 import { light, dark } from "./color-scheme.js";

package/dist/errors.d.ts

@@ -1,7 +1,6 @@
-import { Node } from 'postcss';
 import { PluginContext } from './types.js';
-export declare function reportError(message: string, node: Node, context: PluginContext, options?: {
+export declare function reportError(message: string, node: any, context: PluginContext, options?: {
     word?: string;
     index?: number;
 }): void;
-export declare function reportWarning(message: string, node: Node): void;
+export declare function reportWarning(message: string, node: any, context?: PluginContext): void;

package/dist/errors.js

@@ -5,10 +5,15 @@ export function reportError(message, node, context, options = {}) {
         throw node.error(formattedMessage, options);
     }
     else {
-        reportWarning(formattedMessage, node);
+        reportWarning(formattedMessage, node, context);
     }
 }
-export function reportWarning(message, node) {
-    const result = node.root().toResult();
-    node.warn(result, `[Seyuna PostCSS] ${message}`);
+export function reportWarning(message, node, context) {
+    if (context?.result) {
+        node.warn(context.result, `[Seyuna PostCSS] ${message}`);
+    }
+    else {
+        // Fallback if no result is available (should not happen in main flow)
+        console.warn(`[Seyuna PostCSS Warning] ${message}`);
+    }
 }

package/dist/helpers.d.ts

@@ -1,12 +1,13 @@
-import postcss from "postcss";
-import type { ChildNode, AtRule } from "postcss";
+import Rule from "postcss/lib/rule";
 import { PluginContext } from './types.js';
 /**
  * Helper: clone nodes and replace {name} placeholders safely
  * Returns only valid Rules or Declarations (never raw AtRules)
  */
-export declare function cloneNodes(nodes: ChildNode[], name: string, context: PluginContext): ChildNode[];
+export declare function cloneNodes(nodes: any[], // ChildNode[]
+name: string, context: PluginContext): any[];
 /**
  * Generate CSS rules from a list of names
  */
-export declare function generateRules(names: string[], atRule: AtRule, context: PluginContext): postcss.Rule[];
+export declare function generateRules(names: string[], atRule: any, // AtRule
+context: PluginContext): Rule[];

package/dist/helpers.js

@@ -1,15 +1,17 @@
-import postcss from "postcss";
+import Rule from "postcss/lib/rule";
+// import type { ChildNode, Declaration, AtRule } from "postcss";
 import { processFunctions } from "./parser.js";
 /**
  * Helper: clone nodes and replace {name} placeholders safely
  * Returns only valid Rules or Declarations (never raw AtRules)
  */
-export function cloneNodes(nodes, name, context) {
+export function cloneNodes(nodes, // ChildNode[]
+name, context) {
     const { functions: fnMap } = context;
     return nodes.flatMap((node) => {
         const cloned = node.clone();
         if (cloned.type === "decl") {
-            const decl = cloned;
+            const decl = cloned; // Declaration
             let value = decl.value.replace(/\{name\}/g, name);
             // Process functions using the robust parser
             decl.value = processFunctions(value, fnMap, decl, context);
@@ -33,11 +35,12 @@ export function cloneNodes(nodes, name, context) {
 /**
  * Generate CSS rules from a list of names
  */
-export function generateRules(names, atRule, context) {
+export function generateRules(names, atRule, // AtRule
+context) {
     const nodes = atRule.nodes ?? [];
     const generatedRules = [];
     for (const name of names) {
-        const rule = new postcss.Rule({
+        const rule = new Rule({
             selector: `&.${name}`,
             source: atRule.source,
         });

package/dist/index.d.ts

@@ -1,5 +1,2 @@
-declare const plugin: import("postcss").PluginCreator<import("./types.js").PluginOptions> & {
-    postcss: boolean;
-    functions: Record<string, import("./functions/index.js").FnHandler>;
-};
+declare const plugin: any;
 export default plugin;

package/dist/parser.d.ts

@@ -1,4 +1,3 @@
-import { Node } from 'postcss';
 import { PluginContext, FunctionMap } from './types.js';
 export type { FunctionMap } from './types.js';
-export declare function processFunctions(value: string, fnMap: FunctionMap, node: Node, context: PluginContext): string;
+export declare function processFunctions(value: string, fnMap: FunctionMap, node: any, context: PluginContext): string;

package/dist/plugin.d.ts

@@ -1,3 +1 @@
-import type { PluginCreator } from "postcss";
-import { PluginOptions } from "./types.js";
-export declare const dynamicFunctionsPlugin: PluginCreator<PluginOptions>;
+export declare const dynamicFunctionsPlugin: any;

package/dist/plugin.js

@@ -1,3 +1,4 @@
+// import type { PluginCreator } from "postcss";
 import { functions } from "./functions/index.js";
 import { atRuleHandlers } from "./at-rules/index.js";
 import { loadConfigAsync } from "./config.js";
@@ -8,18 +9,29 @@ export const dynamicFunctionsPlugin = (opts = {}) => {
     return {
         postcssPlugin: "postcss-dynamic-functions",
         async Once() {
-            const { config, options } = await loadConfigAsync(opts);
-            fnMap = { ...functions, ...opts.functions };
-            context = {
-                config,
-                options,
-                functions: fnMap,
-            };
+            try {
+                const { config, options } = await loadConfigAsync(opts);
+                fnMap = { ...functions, ...opts.functions };
+                context = {
+                    config,
+                    options,
+                    functions: fnMap,
+                    result: undefined
+                };
+            }
+            catch (e) {
+                throw e;
+            }
         },
-        Declaration(decl) {
+        Declaration(decl, { result }) {
             if (!context || !fnMap)
                 return;
-            decl.value = processFunctions(decl.value, fnMap, decl, context);
+            // Update context with the current result object
+            context.result = result;
+            const newValue = processFunctions(decl.value, fnMap, decl, context);
+            if (newValue !== decl.value) {
+                decl.value = newValue;
+            }
         },
         // Override AtRule handler to ensure ordered execution
         AtRule(atRule) {

package/dist/types.d.ts

@@ -56,4 +56,5 @@ export interface PluginContext {
     config: SeyunaConfig;
     options: Required<PluginOptions>;
     functions: FunctionMap;
+    result?: any;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seyuna/postcss",
-  "version": "1.0.0-canary.23",
+  "version": "1.0.0-canary.25",
   "description": "Seyuna UI's postcss plugin",
   "type": "module",
   "main": "dist/index.js",

package/src/at-rules/color-scheme.ts

@@ -1,25 +1,26 @@
-import postcss from "postcss";
-import type { AtRule, ChildNode } from "postcss";
+import Rule from "postcss/lib/rule";
+import AtRule from "postcss/lib/at-rule";
+// import type { ChildNode } from "postcss";
 import { PluginContext } from "../types.js";
 
 /**
  * Custom PostCSS plugin handler factory for `@light` and `@dark` at-rules.
  */
 function createColorSchemeHandler(scheme: 'light' | 'dark') {
-  return (atRule: AtRule, context: PluginContext) => {
+  return (atRule: any, context: PluginContext) => {
     const { options } = context;
     const modeAttribute = options.modeAttribute;
-    const clonedNodes: ChildNode[] = [];
+    const clonedNodes: any[] = [];
 
     // Clone all child nodes inside the block
-    atRule.each((node: ChildNode) => {
+    atRule.each((node: any) => {
       clonedNodes.push(node.clone());
     });
 
     /**
      * Rule 1: [data-mode="scheme"] & { ... } (Explicit mode)
      */
-    const explicitRule = new postcss.Rule({
+    const explicitRule = new Rule({
       selector: `[${modeAttribute}="${scheme}"] &`,
       source: atRule.source,
     });
@@ -28,13 +29,13 @@ function createColorSchemeHandler(scheme: 'light' | 'dark') {
     /**
      * Rule 2: @media (prefers-color-scheme: scheme) { [data-mode="system"] & { ... } } (System preference)
      */
-    const mediaAtRule = new postcss.AtRule({
+    const mediaAtRule = new AtRule({
       name: "media",
       params: `(prefers-color-scheme: ${scheme})`,
       source: atRule.source,
     });
 
-    const systemRule = new postcss.Rule({
+    const systemRule = new Rule({
       selector: `[${modeAttribute}="system"] &`,
       source: atRule.source,
     });

package/src/at-rules/color.ts

@@ -1,11 +1,11 @@
-import type { AtRule } from "postcss";
+// import type { AtRule } from "postcss";
 import { PluginContext } from "../types.js";
 import { generateRules } from "../helpers.js";
 
 /**
  * Handler for @each-standard-color
  */
-export function eachStandardColor(atRule: AtRule, context: PluginContext) {
+export function eachStandardColor(atRule: any, context: PluginContext) {
   const { config } = context;
   const hueNames = config.ui ? Object.keys(config.ui.theme.hues) : [];
 
@@ -17,7 +17,7 @@ export function eachStandardColor(atRule: AtRule, context: PluginContext) {
 /**
  * Handler for @each-fixed-color
  */
-export function eachFixedColor(atRule: AtRule, context: PluginContext) {
+export function eachFixedColor(atRule: any, context: PluginContext) {
   const { config } = context;
 
   const mergedNames = [

package/src/at-rules/container.ts

@@ -1,5 +1,5 @@
-import postcss from "postcss";
-import type { AtRule, ChildNode } from "postcss";
+import AtRule from "postcss/lib/at-rule";
+// import type { ChildNode } from "postcss"; // AtRule is now a value import
 import { PluginContext } from "../types.js";
 
 /**
@@ -18,7 +18,7 @@ import { PluginContext } from "../types.js";
  *   }
  *
  */
-export default function container(atRule: AtRule, context: PluginContext) {
+export default function container(atRule: any, context: PluginContext) {
   const { config } = context;
   
   // Default breakpoints
@@ -40,12 +40,12 @@ export default function container(atRule: AtRule, context: PluginContext) {
   if (Object.keys(breakpoints).includes(atRule.name)) {
     const minWidth = breakpoints[atRule.name];
 
-    const clonedNodes: ChildNode[] = [];
-    atRule.each((node: ChildNode) => {
+    const clonedNodes: any[] = [];
+    atRule.each((node: any) => {
       clonedNodes.push(node.clone());
     });
 
-    const containerAtRule = new postcss.AtRule({
+    const containerAtRule = new AtRule({
       name: "container",
       params: `(min-width: ${minWidth})`,
       source: atRule.source,

package/src/at-rules/index.ts

@@ -1,4 +1,4 @@
-import type { AtRule } from "postcss";
+// import type { AtRule } from "postcss";
 import { eachStandardColor, eachFixedColor } from "./color.js";
 import container from "./container.js";
 import { light, dark } from "./color-scheme.js";
@@ -7,7 +7,7 @@ import { PluginContext } from "../types.js";
 // Each handler has a name (matches the at-rule) and the function
 export interface AtRuleHandler {
   name: string;
-  handler: (atRule: AtRule, context: PluginContext) => void;
+  handler: (atRule: any, context: PluginContext) => void;
 }
 
 // Ordered array ensures execution order

package/src/errors.ts

@@ -1,9 +1,9 @@
-import { Node } from 'postcss';
+// import type { Node } from 'postcss';
 import { PluginContext } from './types.js';
 
 export function reportError(
   message: string,
-  node: Node,
+  node: any,
   context: PluginContext,
   options: { word?: string; index?: number } = {}
 ) {
@@ -13,11 +13,15 @@ export function reportError(
   if (pluginOptions.strict) {
     throw node.error(formattedMessage, options);
   } else {
-    reportWarning(formattedMessage, node);
+    reportWarning(formattedMessage, node, context);
   }
 }
 
-export function reportWarning(message: string, node: Node) {
-  const result = node.root().toResult();
-  node.warn(result, `[Seyuna PostCSS] ${message}`);
+export function reportWarning(message: string, node: any, context?: PluginContext) {
+  if (context?.result) {
+    node.warn(context.result, `[Seyuna PostCSS] ${message}`);
+  } else {
+    // Fallback if no result is available (should not happen in main flow)
+    console.warn(`[Seyuna PostCSS Warning] ${message}`);
+  }
 }

package/src/helpers.ts

@@ -1,5 +1,5 @@
-import postcss from "postcss";
-import type { ChildNode, Declaration, AtRule } from "postcss";
+import Rule from "postcss/lib/rule";
+// import type { ChildNode, Declaration, AtRule } from "postcss";
 import { processFunctions } from "./parser.js";
 import { PluginContext } from './types.js';
 
@@ -8,17 +8,17 @@ import { PluginContext } from './types.js';
  * Returns only valid Rules or Declarations (never raw AtRules)
  */
 export function cloneNodes(
-  nodes: ChildNode[],
+  nodes: any[], // ChildNode[]
   name: string,
   context: PluginContext
-): ChildNode[] {
+): any[] { // ChildNode[]
   const { functions: fnMap } = context;
   
   return nodes.flatMap((node) => {
     const cloned = node.clone();
 
     if (cloned.type === "decl") {
-      const decl = cloned as Declaration;
+      const decl = cloned as any; // Declaration
       let value = decl.value.replace(/\{name\}/g, name);
 
       // Process functions using the robust parser
@@ -28,7 +28,7 @@ export function cloneNodes(
     }
 
     if (cloned.type === "rule") {
-      const rule = cloned as postcss.Rule;
+      const rule = cloned as Rule;
       if (!rule.selector) return [];
 
       rule.selector = rule.selector.replace(/\{name\}/g, name);
@@ -52,19 +52,19 @@ export function cloneNodes(
  */
 export function generateRules(
   names: string[],
-  atRule: AtRule,
+  atRule: any, // AtRule
   context: PluginContext
-): postcss.Rule[] {
+): Rule[] {
   const nodes = atRule.nodes ?? [];
-  const generatedRules: postcss.Rule[] = [];
+  const generatedRules: Rule[] = [];
 
   for (const name of names) {
-    const rule = new postcss.Rule({
+    const rule = new Rule({
       selector: `&.${name}`,
       source: atRule.source,
     });
     cloneNodes(nodes, name, context).forEach((n) => {
-      if (n.type === "rule" && n.selector && (n as postcss.Rule).nodes?.length) rule.append(n);
+      if (n.type === "rule" && n.selector && (n as Rule).nodes?.length) rule.append(n);
       if (n.type === "decl") rule.append(n);
     });
 

package/src/parser.ts

@@ -1,5 +1,5 @@
 import valueParser from 'postcss-value-parser';
-import { Node } from 'postcss';
+// import type { Node } from 'postcss';
 import { PluginContext, FunctionMap } from './types.js';
 import { reportError } from './errors.js';
 
@@ -9,7 +9,7 @@ export type { FunctionMap } from './types.js';
 export function processFunctions(
   value: string,
   fnMap: FunctionMap,
-  node: Node,
+  node: any,
   context: PluginContext
 ): string {
   const parsed = valueParser(value);

package/src/plugin.ts

@@ -1,11 +1,11 @@
-import type { PluginCreator } from "postcss";
+// import type { PluginCreator } from "postcss";
 import { functions } from "./functions/index.js";
 import { atRuleHandlers } from "./at-rules/index.js";
 import { loadConfig, loadConfigAsync } from "./config.js";
 import { PluginOptions, PluginContext, FunctionMap } from "./types.js";
 import { processFunctions } from "./parser.js";
 
-export const dynamicFunctionsPlugin: PluginCreator<PluginOptions> = (
+export const dynamicFunctionsPlugin: any = (
   opts = {}
 ) => {
   let context: PluginContext | undefined;
@@ -15,22 +15,35 @@ export const dynamicFunctionsPlugin: PluginCreator<PluginOptions> = (
     postcssPlugin: "postcss-dynamic-functions",
 
     async Once() {
-      const { config, options } = await loadConfigAsync(opts);
-      fnMap = { ...functions, ...opts.functions };
-      context = {
-        config,
-        options,
-        functions: fnMap,
-      };
+      try {
+        const { config, options } = await loadConfigAsync(opts);
+        fnMap = { ...functions, ...(opts as any).functions };
+        context = {
+          config,
+          options,
+          functions: fnMap as FunctionMap,
+          result: undefined
+        };
+      } catch (e) {
+        throw e;
+      }
     },
 
-    Declaration(decl) {
+    Declaration(decl: any, { result }: any) {
       if (!context || !fnMap) return;
-      decl.value = processFunctions(decl.value, fnMap, decl, context);
+      
+      // Update context with the current result object
+      context.result = result;
+
+      const newValue = processFunctions(decl.value, fnMap, decl, context);
+      
+      if (newValue !== decl.value) {
+        decl.value = newValue;
+      }
     },
 
     // Override AtRule handler to ensure ordered execution
-    AtRule(atRule) {
+    AtRule(atRule: any) {
       if (!context) return;
       // Iterate over handlers in order (array) instead of object spread
       for (const { name, handler } of atRuleHandlers) {

package/src/types.ts

@@ -69,4 +69,5 @@ export interface PluginContext {
   config: SeyunaConfig;
   options: Required<PluginOptions>;
   functions: FunctionMap;
+  result?: any; // PostCSS Result
 }