@kithinji/arcane 1.0.8 → 1.0.9

package/src/inline/inline.ts

@@ -0,0 +1,320 @@
+import { MacroContext } from "@kithinji/pod";
+import ts from "typescript";
+import fs from "fs";
+import path from "path";
+
+const MIME_TYPES: Record<string, string> = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".webp": "image/webp",
+  ".ico": "image/x-icon",
+  ".bmp": "image/bmp",
+
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".otf": "font/otf",
+  ".eot": "application/vnd.ms-fontobject",
+
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".ogg": "audio/ogg",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+
+  ".pdf": "application/pdf",
+  ".zip": "application/zip",
+
+  ".txt": "text/plain",
+  ".html": "text/html",
+  ".css": "text/css",
+  ".js": "text/javascript",
+  ".json": "application/json",
+  ".xml": "application/xml",
+};
+
+function getMimeType(filePath: string): string {
+  const ext = path.extname(filePath).toLowerCase();
+  return MIME_TYPES[ext] || "application/octet-stream";
+}
+
+function resolveFilePath(
+  filePath: string,
+  context: MacroContext,
+  macroName: string,
+): string {
+  const pathNode = filePath as unknown as ts.Node;
+  const resolvedPath = context.resolveNodeValue(pathNode);
+
+  if (typeof resolvedPath !== "string") {
+    throw new Error(
+      `${macroName} requires a string literal path, got: ${typeof resolvedPath}`,
+    );
+  }
+
+  const sourceFile = context.sourceFile;
+  const sourceDir = path.dirname(sourceFile.fileName);
+  const absolutePath = path.resolve(sourceDir, resolvedPath);
+
+  return absolutePath;
+}
+
+export interface InlineFileOptions {
+  maxSize?: number;
+}
+
+export interface InlineDataURLOptions {
+  maxSize?: number;
+  mimeType?: string;
+}
+
+export interface InlineBase64Options {
+  maxSize?: number;
+}
+
+export function inlineFile$(
+  this: MacroContext,
+  filePath: string,
+  options?: InlineFileOptions,
+): string {
+  const absolutePath = resolveFilePath(filePath, this, "inlineFile$");
+  const maxSize = options?.maxSize || 1024 * 1024;
+
+  let content: string;
+  try {
+    const stats = fs.statSync(absolutePath);
+
+    if (stats.size > maxSize) {
+      throw new Error(
+        `File "${absolutePath}" is too large (${stats.size} bytes). Maximum allowed: ${maxSize} bytes. Consider using uploadFile$ instead.`,
+      );
+    }
+
+    content = fs.readFileSync(absolutePath, "utf-8");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      throw new Error(
+        `File not found: "${absolutePath}" (referenced in ${this.sourceFile.fileName})`,
+      );
+    }
+    throw new Error(
+      `Failed to read file "${absolutePath}": ${
+        error instanceof Error ? error.message : String(error)
+      }`,
+    );
+  }
+
+  return this.factory.createStringLiteral(content) as any;
+}
+
+export function inlineFiles$(
+  this: MacroContext,
+  filePaths: string[],
+  options?: InlineFileOptions,
+): string[] {
+  const pathsNode = filePaths as unknown as ts.Node;
+  const resolvedPaths = this.resolveNodeValue(pathsNode);
+
+  if (!Array.isArray(resolvedPaths)) {
+    throw new Error(
+      `inlineFiles$ requires an array of string literals, got: ${typeof resolvedPaths}`,
+    );
+  }
+
+  const sourceFile = this.sourceFile;
+  const sourceDir = path.dirname(sourceFile.fileName);
+  const maxSize = options?.maxSize || 1024 * 1024;
+
+  const fileContents: string[] = [];
+
+  for (const filePath of resolvedPaths) {
+    if (typeof filePath !== "string") {
+      throw new Error(
+        `inlineFiles$ requires all paths to be string literals, got: ${typeof filePath}`,
+      );
+    }
+
+    const absolutePath = path.resolve(sourceDir, filePath);
+
+    try {
+      const stats = fs.statSync(absolutePath);
+
+      if (stats.size > maxSize) {
+        throw new Error(
+          `File "${absolutePath}" is too large (${stats.size} bytes). Maximum allowed: ${maxSize} bytes.`,
+        );
+      }
+
+      const content = fs.readFileSync(absolutePath, "utf-8");
+      fileContents.push(content);
+    } catch (error) {
+      if (
+        error instanceof Error &&
+        "code" in error &&
+        error.code === "ENOENT"
+      ) {
+        throw new Error(
+          `File not found: "${absolutePath}" (referenced in ${sourceFile.fileName})`,
+        );
+      }
+      throw new Error(
+        `Failed to read file "${absolutePath}": ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      );
+    }
+  }
+
+  const elements = fileContents.map((content) =>
+    this.factory.createStringLiteral(content),
+  );
+
+  return this.factory.createArrayLiteralExpression(elements, true) as any;
+}
+
+export function inlineFileBase64$(
+  this: MacroContext,
+  filePath: string,
+  options?: InlineBase64Options,
+): string {
+  const absolutePath = resolveFilePath(filePath, this, "inlineFileBase64$");
+  const maxSize = options?.maxSize || 100 * 1024;
+
+  let content: string;
+  try {
+    const stats = fs.statSync(absolutePath);
+
+    if (stats.size > maxSize) {
+      throw new Error(
+        `File "${absolutePath}" is too large (${stats.size} bytes). Maximum allowed: ${maxSize} bytes. Consider using uploadFile$ instead.`,
+      );
+    }
+
+    const buffer = fs.readFileSync(absolutePath);
+    content = buffer.toString("base64");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      throw new Error(
+        `File not found: "${absolutePath}" (referenced in ${this.sourceFile.fileName})`,
+      );
+    }
+    throw new Error(
+      `Failed to read file "${absolutePath}": ${
+        error instanceof Error ? error.message : String(error)
+      }`,
+    );
+  }
+
+  return this.factory.createStringLiteral(content) as any;
+}
+
+export function inlineDataURL$(
+  this: MacroContext,
+  filePath: string,
+  options?: InlineDataURLOptions,
+): string {
+  const absolutePath = resolveFilePath(filePath, this, "inlineDataURL$");
+  const maxSize = options?.maxSize || 100 * 1024;
+
+  let dataURL: string;
+  try {
+    const stats = fs.statSync(absolutePath);
+
+    if (stats.size > maxSize) {
+      throw new Error(
+        `File "${absolutePath}" is too large (${stats.size} bytes). Maximum allowed: ${maxSize} bytes. Consider using uploadFile$ instead.`,
+      );
+    }
+
+    const mimeType = options?.mimeType || getMimeType(absolutePath);
+    const buffer = fs.readFileSync(absolutePath);
+    const base64 = buffer.toString("base64");
+
+    dataURL = `data:${mimeType};base64,${base64}`;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      throw new Error(
+        `File not found: "${absolutePath}" (referenced in ${this.sourceFile.fileName})`,
+      );
+    }
+    throw new Error(
+      `Failed to read file "${absolutePath}": ${
+        error instanceof Error ? error.message : String(error)
+      }`,
+    );
+  }
+
+  return this.factory.createStringLiteral(dataURL) as any;
+}
+
+export function inlineDataURLs$(
+  this: MacroContext,
+  filePaths: string[],
+  options?: InlineDataURLOptions,
+): string[] {
+  const pathsNode = filePaths as unknown as ts.Node;
+  const resolvedPaths = this.resolveNodeValue(pathsNode);
+
+  if (!Array.isArray(resolvedPaths)) {
+    throw new Error(
+      `inlineDataURLs$ requires an array of string literals, got: ${typeof resolvedPaths}`,
+    );
+  }
+
+  const sourceFile = this.sourceFile;
+  const sourceDir = path.dirname(sourceFile.fileName);
+  const maxSize = options?.maxSize || 100 * 1024;
+
+  const dataURLs: string[] = [];
+
+  for (const filePath of resolvedPaths) {
+    if (typeof filePath !== "string") {
+      throw new Error(
+        `inlineDataURLs$ requires all paths to be string literals, got: ${typeof filePath}`,
+      );
+    }
+
+    const absolutePath = path.resolve(sourceDir, filePath);
+
+    try {
+      const stats = fs.statSync(absolutePath);
+
+      if (stats.size > maxSize) {
+        throw new Error(
+          `File "${absolutePath}" is too large (${stats.size} bytes). Maximum allowed: ${maxSize} bytes.`,
+        );
+      }
+
+      const mimeType = options?.mimeType || getMimeType(absolutePath);
+      const buffer = fs.readFileSync(absolutePath);
+      const base64 = buffer.toString("base64");
+
+      const dataURL = `data:${mimeType};base64,${base64}`;
+      dataURLs.push(dataURL);
+    } catch (error) {
+      if (
+        error instanceof Error &&
+        "code" in error &&
+        error.code === "ENOENT"
+      ) {
+        throw new Error(
+          `File not found: "${absolutePath}" (referenced in ${sourceFile.fileName})`,
+        );
+      }
+      throw new Error(
+        `Failed to read file "${absolutePath}": ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      );
+    }
+  }
+
+  const elements = dataURLs.map((dataURL) =>
+    this.factory.createStringLiteral(dataURL),
+  );
+
+  return this.factory.createArrayLiteralExpression(elements, true) as any;
+}

package/src/style/style.ts

@@ -43,7 +43,7 @@ function simpleHash(str: string): string {
 function hashProperty(
   prop: string,
   value: string | number,
-  cssRules: Map<string, string>
+  cssRules: Map<string, string>,
 ): string {
   const input = `${prop}:${value}`;
   let hash = simpleHash(input);
@@ -80,7 +80,7 @@ function hashProperty(
 
     if (attempt > 100) {
       throw new Error(
-        `Hash collision limit exceeded for property ${prop}:${value}`
+        `Hash collision limit exceeded for property ${prop}:${value}`,
       );
     }
   }
@@ -123,13 +123,13 @@ function isPseudoOrMediaKey(key: string): boolean {
 function validateStyleValue(value: any, path: string): void {
   if (value === null) {
     throw new Error(
-      `Invalid style value at ${path}: null is not allowed. Use undefined or omit the property.`
+      `Invalid style value at ${path}: null is not allowed. Use undefined or omit the property.`,
     );
   }
 
   if (typeof value === "function") {
     throw new Error(
-      `Invalid style value at ${path}: functions must be resolved at build time.`
+      `Invalid style value at ${path}: functions must be resolved at build time.`,
     );
   }
 }
@@ -138,7 +138,7 @@ function processStyleValue(
   prop: string,
   value: any,
   cssRules: Map<string, string>,
-  path: string = prop
+  path: string = prop,
 ): string {
   validateStyleValue(value, path);
 
@@ -163,7 +163,7 @@ function processStyleValue(
       if (nestedKey === "default") {
         const normalizedValue = normalizeValue(
           prop,
-          nestedValue as string | number
+          nestedValue as string | number,
         );
         const className = hashProperty(prop, normalizedValue, cssRules);
 
@@ -176,12 +176,12 @@ function processStyleValue(
       } else if (isPseudoOrMediaKey(nestedKey)) {
         const normalizedValue = normalizeValue(
           prop,
-          nestedValue as string | number
+          nestedValue as string | number,
         );
         const className = hashProperty(
           `${prop}${nestedKey}`,
           normalizedValue,
-          cssRules
+          cssRules,
         );
 
         if (!cssRules.has(className)) {
@@ -205,7 +205,7 @@ function processStyleValue(
         classes.push(className);
       } else {
         throw new Error(
-          `Invalid nested key "${nestedKey}" at ${path}. Expected "default", a pseudo-class (":hover"), media query ("@media"), or nesting selector ("&").`
+          `Invalid nested key "${nestedKey}" at ${path}. Expected "default", a pseudo-class (":hover"), media query ("@media"), or nesting selector ("&").`,
         );
       }
     }
@@ -226,14 +226,14 @@ function processStyleValue(
 
 function processStyleObject(
   styleObj: Record<string, any>,
-  cssRules: Map<string, string>
+  cssRules: Map<string, string>,
 ): Record<string, string> {
   const result: Record<string, string> = {};
 
   for (const [namespace, styles] of Object.entries(styleObj)) {
     if (typeof styles !== "object" || Array.isArray(styles)) {
       throw new Error(
-        `Invalid style namespace "${namespace}": expected an object, got ${typeof styles}`
+        `Invalid style namespace "${namespace}": expected an object, got ${typeof styles}`,
       );
     }
 
@@ -246,7 +246,7 @@ function processStyleObject(
         prop,
         value,
         cssRules,
-        `${namespace}.${prop}`
+        `${namespace}.${prop}`,
       );
 
       if (className) {
@@ -261,78 +261,62 @@ function processStyleObject(
 }
 
 export function style$<const T extends Record<string, any>>(
+  this: MacroContext,
   style: T,
-  context?: MacroContext
 ): MapNamespaces<T> {
-  if (!context) {
-    throw new Error(
-      "style$ macro requires MacroContext. Ensure you're using this as a build-time macro."
-    );
-  }
-
   const rStyle = style as unknown as ts.Node;
-  const value = context.resolveNodeValue(rStyle);
+  const value = this.resolveNodeValue(rStyle);
 
   if (value == undefined) {
     throw new Error(
       `Could not resolve style object at build time. ` +
-        `Ensure all values are statically analyzable (no runtime expressions, dynamic imports should be inlined).`
+        `Ensure all values are statically analyzable (no runtime expressions, dynamic imports should be inlined).`,
     );
   }
 
   if (typeof value !== "object" || Array.isArray(value)) {
     throw new Error(
-      `style$ expects an object with style namespaces, got ${typeof value}`
+      `style$ expects an object with style namespaces, got ${typeof value}`,
     );
   }
 
   const cssRules = new Map<string, string>();
   const classNameMap = processStyleObject(value, cssRules);
 
-  context.store.set("style_rules", Array.from(cssRules.values()));
+  this.store.set("style_rules", Array.from(cssRules.values()));
 
   const properties = Object.entries(classNameMap).map(([key, className]) =>
-    context.factory.createPropertyAssignment(
-      context.factory.createStringLiteral(key),
-      context.factory.createStringLiteral(className)
-    )
+    this.factory.createPropertyAssignment(
+      this.factory.createStringLiteral(key),
+      this.factory.createStringLiteral(className),
+    ),
   );
 
-  return context.factory.createObjectLiteralExpression(properties, true) as any;
+  return this.factory.createObjectLiteralExpression(properties, true) as any;
 }
 
 type Fragment =
   | { kind: "static"; value: string }
   | { kind: "dynamic"; expr: ts.Expression; stringSafe: boolean };
 
-export function apply$(...c: any[]) {
-  if (c.length < 1) {
-    throw new Error("apply$ requires at least one argument plus MacroContext");
-  }
-
-  const context = c.pop() as MacroContext;
-
-  if (!context || !context.factory) {
-    throw new Error(
-      "apply$ macro requires MacroContext as the last argument. Ensure you're using this as a build-time macro."
-    );
-  }
-
+export function apply$(this: MacroContext, ...c: any[]) {
   const args = c as ts.Expression[];
 
+  const self = this;
+
   if (args.length === 0) {
-    return context.factory.createObjectLiteralExpression(
+    return self.factory.createObjectLiteralExpression(
       [
-        context.factory.createPropertyAssignment(
-          context.factory.createIdentifier("className"),
-          context.factory.createStringLiteral("")
+        self.factory.createPropertyAssignment(
+          self.factory.createIdentifier("className"),
+          self.factory.createStringLiteral(""),
         ),
       ],
-      false
+      false,
     );
   }
 
-  const f = context.factory;
+  const f = self.factory;
 
   function isTrue(e: ts.Expression): boolean {
     return e.kind === ts.SyntaxKind.TrueKeyword;
@@ -366,8 +350,8 @@ export function apply$(...c: any[]) {
     if (!ts.isIdentifier(cur)) return null;
     chain.unshift(cur.text);
 
-    const root = context.resolveIdentifier(f.createIdentifier(chain[0]));
-    let value = context.resolveNodeValue(root);
+    const root = self.resolveIdentifier(f.createIdentifier(chain[0]));
+    let value = self.resolveNodeValue(root);
 
     if (value == null) return null;
 
@@ -412,7 +396,7 @@ export function apply$(...c: any[]) {
               f.createStringLiteral(""),
               f.createStringLiteral(rs),
             ]),
-            f.createPrefixUnaryExpression(ts.SyntaxKind.PlusToken, expr.left)
+            f.createPrefixUnaryExpression(ts.SyntaxKind.PlusToken, expr.left),
           ),
         };
       }
@@ -440,8 +424,8 @@ export function apply$(...c: any[]) {
             ]),
             f.createPrefixUnaryExpression(
               ts.SyntaxKind.PlusToken,
-              expr.condition
-            )
+              expr.condition,
+            ),
           ),
         };
       }
@@ -485,7 +469,7 @@ export function apply$(...c: any[]) {
       frags
         .map((f) => f.value)
         .join(" ")
-        .trim()
+        .trim(),
     );
   } else {
     // Mixed static/dynamic - generate array.join(" ")
@@ -505,19 +489,19 @@ export function apply$(...c: any[]) {
               undefined,
               frag.expr,
               undefined,
-              f.createStringLiteral("")
+              f.createStringLiteral(""),
             );
-          })
+          }),
         ),
-        "join"
+        "join",
       ),
       undefined,
-      [f.createStringLiteral(" ")]
+      [f.createStringLiteral(" ")],
     );
   }
 
   return f.createObjectLiteralExpression(
     [f.createPropertyAssignment(f.createIdentifier("className"), classExpr)],
-    false
+    false,
   );
 }

package/src/inline-file/inline.ts

@@ -1,90 +0,0 @@
-import { MacroContext } from "@kithinji/pod";
-import ts from "typescript";
-import fs from "fs";
-import path from "path";
-
-export function inlineFile$(filePath: string, context?: MacroContext): string {
-  if (!context) {
-    throw new Error(
-      "inlineFile$ macro requires MacroContext. Ensure you're using this as a build-time macro."
-    );
-  }
-
-  const pathNode = filePath as unknown as ts.Node;
-  const resolvedPath = context.resolveNodeValue(pathNode);
-
-  if (typeof resolvedPath !== "string") {
-    throw new Error(
-      `inlineFile$ macro requires a string literal path, got: ${typeof resolvedPath}`
-    );
-  }
-
-  const sourceFile = context.sourceFile;
-  const sourceDir = path.dirname(sourceFile.fileName);
-  const absolutePath = path.resolve(sourceDir, resolvedPath);
-
-  let content: string;
-  try {
-    content = fs.readFileSync(absolutePath, "utf-8");
-  } catch (error) {
-    throw new Error(
-      `Failed to read file "${absolutePath}": ${
-        error instanceof Error ? error.message : String(error)
-      }`
-    );
-  }
-
-  return context.factory.createStringLiteral(content) as any;
-}
-
-export function inlineFiles$(
-  filePaths: string[],
-  context?: MacroContext
-): string[] {
-  if (!context) {
-    throw new Error(
-      "inlineFiles$ macro requires MacroContext. Ensure you're using this as a build-time macro."
-    );
-  }
-
-  const pathsNode = filePaths as unknown as ts.Node;
-  const resolvedPaths = context.resolveNodeValue(pathsNode);
-
-  if (!Array.isArray(resolvedPaths)) {
-    throw new Error(
-      `inlineFiles$ macro requires an array of string literals, got: ${typeof resolvedPaths}`
-    );
-  }
-
-  const sourceFile = context.sourceFile;
-  const sourceDir = path.dirname(sourceFile.fileName);
-
-  const fileContents: string[] = [];
-
-  for (const filePath of resolvedPaths) {
-    if (typeof filePath !== "string") {
-      throw new Error(
-        `inlineFiles$ macro requires all paths to be string literals, got: ${typeof filePath}`
-      );
-    }
-
-    const absolutePath = path.resolve(sourceDir, filePath);
-
-    try {
-      const content = fs.readFileSync(absolutePath, "utf-8");
-      fileContents.push(content);
-    } catch (error) {
-      throw new Error(
-        `Failed to read file "${absolutePath}": ${
-          error instanceof Error ? error.message : String(error)
-        }`
-      );
-    }
-  }
-
-  const elements = fileContents.map((content) =>
-    context.factory.createStringLiteral(content)
-  );
-
-  return context.factory.createArrayLiteralExpression(elements, true) as any;
-}