@salty-css/core 0.0.1-alpha.304 → 0.0.1-alpha.306

package/compiler/as-class.cjs

@@ -560,6 +560,88 @@ ${current}`;
       }
       return void 0;
     });
+    __publicField(this, "generateFile", async (file) => {
+      try {
+        const destDir = await this.getDestDir();
+        const validFile = compiler_helpers.isSaltyFile(file);
+        if (validFile) {
+          const cssFiles = [];
+          const config = await this.getConfig();
+          const { contents } = await this.compileSaltyFile(file, destDir);
+          for (const [name, value] of Object.entries(contents)) {
+            const resolved = await compiler_helpers.resolveExportValue(value, 1);
+            if (resolved.isKeyframes && resolved.css) {
+              const fileName = `a_${resolved.animationName}.css`;
+              const filePath2 = `css/${fileName}`;
+              const cssPath2 = path.join(destDir, filePath2);
+              fs.writeFileSync(cssPath2, await resolved.css);
+              continue;
+            }
+            if (resolved.isClassName) {
+              const generator2 = resolved.generator._withBuildContext({
+                callerName: name,
+                isProduction: this.isProduction,
+                config
+              });
+              const styles2 = await generator2.css;
+              if (!styles2) continue;
+              if (!cssFiles[generator2.priority]) cssFiles[generator2.priority] = [];
+              cssFiles[generator2.priority].push(generator2.cssFileName);
+              const filePath2 = `css/${generator2.cssFileName}`;
+              const cssPath2 = path.join(destDir, filePath2);
+              fs.writeFileSync(cssPath2, styles2);
+              continue;
+            }
+            if (!resolved.generator) continue;
+            const generator = resolved.generator._withBuildContext({
+              callerName: name,
+              isProduction: this.isProduction,
+              config
+            });
+            const styles = await generator.css;
+            if (!styles) continue;
+            const filePath = `css/${generator.cssFileName}`;
+            const cssPath = path.join(destDir, filePath);
+            fs.writeFileSync(cssPath, styles);
+            if (!cssFiles[generator.priority]) cssFiles[generator.priority] = [];
+            cssFiles[generator.priority].push(generator.cssFileName);
+          }
+          if (config.importStrategy !== "component") {
+            cssFiles.forEach((val, layer) => {
+              const layerFileName = `l_${layer}.css`;
+              const layerFilePath = path.join(destDir, "css", layerFileName);
+              let currentLayerFileContent = fs.readFileSync(layerFilePath, "utf8");
+              val.forEach((file2) => {
+                var _a;
+                const filepath = path.join(destDir, "css", file2);
+                const filepathHash = ((_a = /.*-([^-]+)-\d+.css/.exec(file2)) == null ? void 0 : _a.at(1)) || dashCase.toHash(filepath, 6);
+                const found = currentLayerFileContent.includes(filepathHash);
+                if (!found) {
+                  const css = fs.readFileSync(filepath, "utf8");
+                  const newContent = `/*start:${filepathHash}-${file2}*/
+${css}
+/*end:${filepathHash}*/
+`;
+                  currentLayerFileContent = `${currentLayerFileContent.replace(/\}$/, "")}
+${newContent}
+}`;
+                }
+              });
+              fs.writeFileSync(layerFilePath, currentLayerFileContent);
+            });
+          } else {
+            const cssContent = cssFiles.flat().map((file2) => `@import url('./${file2}');`).join("\n");
+            const hashName = dashCase.toHash(file, 6);
+            const parsedPath = path.parse(file);
+            const dasherized = dashCase.dashCase(parsedPath.name);
+            const cssFile = path.join(destDir, `css/f_${dasherized}-${hashName}.css`);
+            fs.writeFileSync(cssFile, cssContent || `/* Empty file */`);
+          }
+        }
+      } catch (e) {
+        console.error(e);
+      }
+    });
     __publicField(this, "replaceStyledTag", (currentFile) => {
       return currentFile.replace(/styled\(([^"'`{,]+),/g, (match, tag) => {
         const isString = /^['"`]/.test(tag);

package/compiler/as-class.d.ts

@@ -29,7 +29,24 @@ export declare class SaltyCompiler {
      */
     generateCss: (clean?: boolean) => Promise<void>;
     private generateConfigStyles;
-    private compileSaltyFile;
+    compileSaltyFile: (sourceFilePath: string, outputDirectory: string) => Promise<{
+        contents: {
+            [key: string]: {
+                generator: any;
+                isClassName?: boolean;
+                isMedia?: boolean;
+                isGlobalDefine?: boolean;
+                isDefineVariables?: boolean;
+                isDefineTemplates?: boolean;
+                isKeyframes?: boolean;
+                animationName?: string;
+                css?: Promise<string>;
+                styles?: any;
+            };
+        };
+        outputFilePath: string;
+    }>;
     minimizeFile: (file: string) => Promise<string | undefined>;
+    generateFile: (file: string) => Promise<void>;
     private replaceStyledTag;
 }

package/compiler/as-class.js

@@ -541,6 +541,88 @@ ${current}`;
       }
       return void 0;
     });
+    __publicField(this, "generateFile", async (file) => {
+      try {
+        const destDir = await this.getDestDir();
+        const validFile = isSaltyFile(file);
+        if (validFile) {
+          const cssFiles = [];
+          const config = await this.getConfig();
+          const { contents } = await this.compileSaltyFile(file, destDir);
+          for (const [name, value] of Object.entries(contents)) {
+            const resolved = await resolveExportValue(value, 1);
+            if (resolved.isKeyframes && resolved.css) {
+              const fileName = `a_${resolved.animationName}.css`;
+              const filePath2 = `css/${fileName}`;
+              const cssPath2 = join(destDir, filePath2);
+              writeFileSync(cssPath2, await resolved.css);
+              continue;
+            }
+            if (resolved.isClassName) {
+              const generator2 = resolved.generator._withBuildContext({
+                callerName: name,
+                isProduction: this.isProduction,
+                config
+              });
+              const styles2 = await generator2.css;
+              if (!styles2) continue;
+              if (!cssFiles[generator2.priority]) cssFiles[generator2.priority] = [];
+              cssFiles[generator2.priority].push(generator2.cssFileName);
+              const filePath2 = `css/${generator2.cssFileName}`;
+              const cssPath2 = join(destDir, filePath2);
+              writeFileSync(cssPath2, styles2);
+              continue;
+            }
+            if (!resolved.generator) continue;
+            const generator = resolved.generator._withBuildContext({
+              callerName: name,
+              isProduction: this.isProduction,
+              config
+            });
+            const styles = await generator.css;
+            if (!styles) continue;
+            const filePath = `css/${generator.cssFileName}`;
+            const cssPath = join(destDir, filePath);
+            writeFileSync(cssPath, styles);
+            if (!cssFiles[generator.priority]) cssFiles[generator.priority] = [];
+            cssFiles[generator.priority].push(generator.cssFileName);
+          }
+          if (config.importStrategy !== "component") {
+            cssFiles.forEach((val, layer) => {
+              const layerFileName = `l_${layer}.css`;
+              const layerFilePath = join(destDir, "css", layerFileName);
+              let currentLayerFileContent = readFileSync(layerFilePath, "utf8");
+              val.forEach((file2) => {
+                var _a;
+                const filepath = join(destDir, "css", file2);
+                const filepathHash = ((_a = /.*-([^-]+)-\d+.css/.exec(file2)) == null ? void 0 : _a.at(1)) || toHash(filepath, 6);
+                const found = currentLayerFileContent.includes(filepathHash);
+                if (!found) {
+                  const css = readFileSync(filepath, "utf8");
+                  const newContent = `/*start:${filepathHash}-${file2}*/
+${css}
+/*end:${filepathHash}*/
+`;
+                  currentLayerFileContent = `${currentLayerFileContent.replace(/\}$/, "")}
+${newContent}
+}`;
+                }
+              });
+              writeFileSync(layerFilePath, currentLayerFileContent);
+            });
+          } else {
+            const cssContent = cssFiles.flat().map((file2) => `@import url('./${file2}');`).join("\n");
+            const hashName = toHash(file, 6);
+            const parsedPath = parse(file);
+            const dasherized = dashCase(parsedPath.name);
+            const cssFile = join(destDir, `css/f_${dasherized}-${hashName}.css`);
+            writeFileSync(cssFile, cssContent || `/* Empty file */`);
+          }
+        }
+      } catch (e) {
+        console.error(e);
+      }
+    });
     __publicField(this, "replaceStyledTag", (currentFile) => {
       return currentFile.replace(/styled\(([^"'`{,]+),/g, (match, tag) => {
         const isString = /^['"`]/.test(tag);

package/generators/class-name-generator.d.ts

@@ -3,4 +3,5 @@ import { StyledParams } from '../types';
 export declare class ClassNameGenerator<const STYLE_PARAMS extends StyledParams = StyledParams> extends StylesGenerator<STYLE_PARAMS> {
     _params: STYLE_PARAMS;
     constructor(_params: STYLE_PARAMS);
+    get priority(): number;
 }

package/generators/index.cjs

@@ -65,6 +65,10 @@ class ClassNameGenerator extends StylesGenerator {
     super(_params);
     this._params = _params;
   }
+  get priority() {
+    if (this.params.priority) return this.params.priority;
+    return 0;
+  }
 }
 class StyledGenerator extends StylesGenerator {
   constructor(tagName, _params) {

package/generators/index.js

@@ -63,6 +63,10 @@ class ClassNameGenerator extends StylesGenerator {
     super(_params);
     this._params = _params;
   }
+  get priority() {
+    if (this.params.priority) return this.params.priority;
+    return 0;
+  }
 }
 class StyledGenerator extends StylesGenerator {
   constructor(tagName, _params) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@salty-css/core",
-  "version": "0.0.1-alpha.304",
+  "version": "0.0.1-alpha.306",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "typings": "./dist/index.d.ts",