@wyw-in-js/processor-utils 1.0.5 → 2.0.0-alpha.0

package/esm/utils/validateParams.js

@@ -1,43 +1,33 @@
-// ParamMapping maps each ParamName to its corresponding Param type.
-
-// GetParamByName returns the Param type based on the input type T.
-
-// If T is none of the above, return never.
-
-// MapParams iteratively maps the input ParamConstraints to their corresponding Param types.
-
-// If TNames is an empty tuple, return the result tuple.
-
 export function isValidParams(params, constraints) {
-  const length = Math.max(params.length, constraints.length);
-  for (let i = 0; i < length; i++) {
-    if (params[i] === undefined || constraints[i] === undefined) {
-      return false;
-    }
-    const constraint = constraints[i];
-    if (constraint === '...') {
-      return true;
-    }
-    if (constraint === '*') {
-      if (params[i] === undefined) {
-        return false;
-      }
-    } else if (Array.isArray(constraint)) {
-      if (constraint.every(c => c !== params[i]?.[0])) {
-        return false;
-      }
-    } else if (constraint !== params[i]?.[0]) {
-      return false;
-    }
-  }
-  return true;
+	const length = Math.max(params.length, constraints.length);
+	for (let i = 0; i < length; i++) {
+		if (params[i] === undefined || constraints[i] === undefined) {
+			return false;
+		}
+		const constraint = constraints[i];
+		if (constraint === "...") {
+			return true;
+		}
+		if (constraint === "*") {
+			if (params[i] === undefined) {
+				return false;
+			}
+		} else if (Array.isArray(constraint)) {
+			if (constraint.every((c) => c !== params[i]?.[0])) {
+				return false;
+			}
+		} else if (constraint !== params[i]?.[0]) {
+			return false;
+		}
+	}
+	return true;
 }
 export function validateParams(params, constraints, messageOrError) {
-  if (!isValidParams(params, constraints)) {
-    if (typeof messageOrError === 'string') {
-      throw new Error(messageOrError);
-    }
-    throw messageOrError;
-  }
+	if (!isValidParams(params, constraints)) {
+		if (typeof messageOrError === "string") {
+			throw new Error(messageOrError);
+		}
+		throw messageOrError;
+	}
 }
-//# sourceMappingURL=validateParams.js.map
+//# sourceMappingURL=validateParams.js.map

package/esm/utils/validateParams.js.map

@@ -1 +1 @@
-{"version":3,"file":"validateParams.js","names":["isValidParams","params","constraints","length","Math","max","i","undefined","constraint","Array","isArray","every","c","validateParams","messageOrError","Error"],"sources":["../../src/utils/validateParams.ts"],"sourcesContent":["import type { Param, Params } from '../types';\n\ntype ParamName = Param[0];\ntype ParamConstraint = ParamName | [...ParamName[]] | '*';\n\nexport type ParamConstraints =\n  | [...ParamConstraint[]]\n  | [...ParamConstraint[], '...'];\n\n// ParamMapping maps each ParamName to its corresponding Param type.\ntype ParamMapping = {\n  [K in ParamName]: Extract<Param, readonly [K, ...unknown[]]>; // For each ParamName K, extract the corresponding Param type.\n};\n\n// GetParamByName returns the Param type based on the input type T.\ntype GetParamByName<T> = T extends '*'\n  ? Param // If T is '*', return Param type.\n  : T extends keyof ParamMapping // If T is a key in ParamMapping (i.e., a ParamName).\n  ? ParamMapping[T] // Return the corresponding Param type from ParamMapping.\n  : T extends Array<infer TNames> // If T is an array of names.\n  ? TNames extends ParamName // If TNames is a ParamName.\n    ? Extract<Param, readonly [TNames, ...unknown[]]> // Return the corresponding Param type.\n    : never // If TNames is not a ParamName, return never.\n  : never; // If T is none of the above, return never.\n\n// MapParams iteratively maps the input ParamConstraints to their corresponding Param types.\nexport type MapParams<\n  TNames extends ParamConstraints,\n  TRes extends Param[] = [],\n> = TNames extends [infer THead, ...infer TTail] // If TNames is a non-empty tuple.\n  ? THead extends '...' // If the first element in the tuple is '...'.\n    ? [...TRes, ...Params] // Append all Params to the result tuple.\n    : MapParams<\n        Extract<TTail, ParamConstraints>, // Extract the remaining ParamConstraints.\n        [...TRes, GetParamByName<Extract<THead, ParamName | '*' | ParamName[]>>] // Append the mapped Param to the result tuple and recurse.\n      >\n  : TRes; // If TNames is an empty tuple, return the result tuple.\n\nexport function isValidParams<T extends ParamConstraints>(\n  params: Params,\n  constraints: T\n): params is MapParams<T> {\n  const length = Math.max(params.length, constraints.length);\n  for (let i = 0; i < length; i++) {\n    if (params[i] === undefined || constraints[i] === undefined) {\n      return false;\n    }\n\n    const constraint = constraints[i];\n    if (constraint === '...') {\n      return true;\n    }\n\n    if (constraint === '*') {\n      if (params[i] === undefined) {\n        return false;\n      }\n    } else if (Array.isArray(constraint)) {\n      if (constraint.every((c) => c !== params[i]?.[0])) {\n        return false;\n      }\n    } else if (constraint !== params[i]?.[0]) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nexport function validateParams<T extends ParamConstraints>(\n  params: Params,\n  constraints: T,\n  messageOrError: unknown\n): asserts params is MapParams<T> {\n  if (!isValidParams(params, constraints)) {\n    if (typeof messageOrError === 'string') {\n      throw new Error(messageOrError);\n    }\n\n    throw messageOrError;\n  }\n}\n"],"mappings":"AASA;;AAKA;;AASW;;AAEX;;AAWU;;AAEV,OAAO,SAASA,aAAaA,CAC3BC,MAAc,EACdC,WAAc,EACU;EACxB,MAAMC,MAAM,GAAGC,IAAI,CAACC,GAAG,CAACJ,MAAM,CAACE,MAAM,EAAED,WAAW,CAACC,MAAM,CAAC;EAC1D,KAAK,IAAIG,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGH,MAAM,EAAEG,CAAC,EAAE,EAAE;IAC/B,IAAIL,MAAM,CAACK,CAAC,CAAC,KAAKC,SAAS,IAAIL,WAAW,CAACI,CAAC,CAAC,KAAKC,SAAS,EAAE;MAC3D,OAAO,KAAK;IACd;IAEA,MAAMC,UAAU,GAAGN,WAAW,CAACI,CAAC,CAAC;IACjC,IAAIE,UAAU,KAAK,KAAK,EAAE;MACxB,OAAO,IAAI;IACb;IAEA,IAAIA,UAAU,KAAK,GAAG,EAAE;MACtB,IAAIP,MAAM,CAACK,CAAC,CAAC,KAAKC,SAAS,EAAE;QAC3B,OAAO,KAAK;MACd;IACF,CAAC,MAAM,IAAIE,KAAK,CAACC,OAAO,CAACF,UAAU,CAAC,EAAE;MACpC,IAAIA,UAAU,CAACG,KAAK,CAAEC,CAAC,IAAKA,CAAC,KAAKX,MAAM,CAACK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE;QACjD,OAAO,KAAK;MACd;IACF,CAAC,MAAM,IAAIE,UAAU,KAAKP,MAAM,CAACK,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE;MACxC,OAAO,KAAK;IACd;EACF;EAEA,OAAO,IAAI;AACb;AAEA,OAAO,SAASO,cAAcA,CAC5BZ,MAAc,EACdC,WAAc,EACdY,cAAuB,EACS;EAChC,IAAI,CAACd,aAAa,CAACC,MAAM,EAAEC,WAAW,CAAC,EAAE;IACvC,IAAI,OAAOY,cAAc,KAAK,QAAQ,EAAE;MACtC,MAAM,IAAIC,KAAK,CAACD,cAAc,CAAC;IACjC;IAEA,MAAMA,cAAc;EACtB;AACF","ignoreList":[]}
+{"mappings":"AAsCA,OAAO,SAAS,cACd,QACA,aACwB;CACxB,MAAM,SAAS,KAAK,IAAI,OAAO,QAAQ,YAAY,OAAO;AAC1D,MAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,KAAK;AAC/B,MAAI,OAAO,OAAO,aAAa,YAAY,OAAO,WAAW;AAC3D,UAAO;;EAGT,MAAM,aAAa,YAAY;AAC/B,MAAI,eAAe,OAAO;AACxB,UAAO;;AAGT,MAAI,eAAe,KAAK;AACtB,OAAI,OAAO,OAAO,WAAW;AAC3B,WAAO;;aAEA,MAAM,QAAQ,WAAW,EAAE;AACpC,OAAI,WAAW,OAAO,MAAM,MAAM,OAAO,KAAK,GAAG,EAAE;AACjD,WAAO;;aAEA,eAAe,OAAO,KAAK,IAAI;AACxC,UAAO;;;AAIX,QAAO;;AAGT,OAAO,SAAS,eACd,QACA,aACA,gBACgC;AAChC,KAAI,CAAC,cAAc,QAAQ,YAAY,EAAE;AACvC,MAAI,OAAO,mBAAmB,UAAU;AACtC,SAAM,IAAI,MAAM,eAAe;;AAGjC,QAAM","names":[],"sources":["../../src/utils/validateParams.ts"],"version":3,"sourcesContent":["import type { Param, Params } from '../types';\n\ntype ParamName = Param[0];\ntype ParamConstraint = ParamName | [...ParamName[]] | '*';\n\nexport type ParamConstraints =\n  | [...ParamConstraint[]]\n  | [...ParamConstraint[], '...'];\n\n// ParamMapping maps each ParamName to its corresponding Param type.\ntype ParamMapping = {\n  [K in ParamName]: Extract<Param, readonly [K, ...unknown[]]>; // For each ParamName K, extract the corresponding Param type.\n};\n\n// GetParamByName returns the Param type based on the input type T.\ntype GetParamByName<T> = T extends '*'\n  ? Param // If T is '*', return Param type.\n  : T extends keyof ParamMapping // If T is a key in ParamMapping (i.e., a ParamName).\n  ? ParamMapping[T] // Return the corresponding Param type from ParamMapping.\n  : T extends Array<infer TNames> // If T is an array of names.\n  ? TNames extends ParamName // If TNames is a ParamName.\n    ? Extract<Param, readonly [TNames, ...unknown[]]> // Return the corresponding Param type.\n    : never // If TNames is not a ParamName, return never.\n  : never; // If T is none of the above, return never.\n\n// MapParams iteratively maps the input ParamConstraints to their corresponding Param types.\nexport type MapParams<\n  TNames extends ParamConstraints,\n  TRes extends Param[] = [],\n> = TNames extends [infer THead, ...infer TTail] // If TNames is a non-empty tuple.\n  ? THead extends '...' // If the first element in the tuple is '...'.\n    ? [...TRes, ...Params] // Append all Params to the result tuple.\n    : MapParams<\n        Extract<TTail, ParamConstraints>, // Extract the remaining ParamConstraints.\n        [...TRes, GetParamByName<Extract<THead, ParamName | '*' | ParamName[]>>] // Append the mapped Param to the result tuple and recurse.\n      >\n  : TRes; // If TNames is an empty tuple, return the result tuple.\n\nexport function isValidParams<T extends ParamConstraints>(\n  params: Params,\n  constraints: T\n): params is MapParams<T> {\n  const length = Math.max(params.length, constraints.length);\n  for (let i = 0; i < length; i++) {\n    if (params[i] === undefined || constraints[i] === undefined) {\n      return false;\n    }\n\n    const constraint = constraints[i];\n    if (constraint === '...') {\n      return true;\n    }\n\n    if (constraint === '*') {\n      if (params[i] === undefined) {\n        return false;\n      }\n    } else if (Array.isArray(constraint)) {\n      if (constraint.every((c) => c !== params[i]?.[0])) {\n        return false;\n      }\n    } else if (constraint !== params[i]?.[0]) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nexport function validateParams<T extends ParamConstraints>(\n  params: Params,\n  constraints: T,\n  messageOrError: unknown\n): asserts params is MapParams<T> {\n  if (!isValidParams(params, constraints)) {\n    if (typeof messageOrError === 'string') {\n      throw new Error(messageOrError);\n    }\n\n    throw messageOrError;\n  }\n}\n"],"file":"validateParams.js"}

package/package.json

@@ -1,37 +1,37 @@
 {
   "name": "@wyw-in-js/processor-utils",
-  "version": "1.0.5",
+  "version": "2.0.0-alpha.0",
+  "type": "module",
   "dependencies": {
-    "@babel/generator": "^7.23.5",
-    "@wyw-in-js/shared": "1.0.5"
+    "@wyw-in-js/shared": "2.0.0-alpha.0"
   },
   "devDependencies": {
-    "@babel/types": "^7.23.5",
-    "@types/babel__core": "^7.20.5",
-    "@types/babel__generator": "^7.6.7",
-    "@types/node": "^16.18.55",
-    "@wyw-in-js/babel-config": "workspace:*",
+    "@types/node": "^22.0.0",
     "@wyw-in-js/eslint-config": "workspace:*",
     "@wyw-in-js/ts-config": "workspace:*",
     "typescript": "^5.2.2"
   },
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=22.0.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "default": "./esm/index.js"
+    }
   },
   "files": [
-    "types/",
-    "lib/",
-    "esm/"
+    "esm/",
+    "types/"
   ],
   "license": "MIT",
-  "main": "lib/index.js",
+  "main": "esm/index.js",
   "module": "esm/index.js",
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build:esm": "babel src --out-dir esm --extensions '.js,.jsx,.ts,.tsx' --source-maps --delete-dir-on-start",
-    "build:lib": "cross-env NODE_ENV=legacy babel src --out-dir lib --extensions '.js,.jsx,.ts,.tsx' --source-maps --delete-dir-on-start",
+    "build:esm": "node ../../scripts/build-esm-oxc.mjs",
     "build:types": "tsc --project ./tsconfig.lib.json --baseUrl . --rootDir ./src",
     "lint": "eslint --ext .js,.ts .",
     "test": "bun test src"

package/types/BaseProcessor.d.ts

@@ -1,9 +1,8 @@
-import type { NodePath, types as t } from '@babel/core';
-import type { Expression, Identifier, SourceLocation, MemberExpression } from '@babel/types';
 import type { Artifact, ExpressionValue } from '@wyw-in-js/shared';
-import type { IInterpolation, Params, Value, ValueCache } from './types';
+import type { AstService, Expression, Identifier, MemberExpression, SourceLocation } from './ast';
+import type { IInterpolation, Params, ProcessorDiagnostic, Value, ValueCache } from './types';
 import type { IFileContext, IOptions } from './utils/types';
-export { Expression };
+export type { Expression };
 export type ProcessorParams = ConstructorParameters<typeof BaseProcessor>;
 export type TailProcessorParams = ProcessorParams extends [Params, ...infer T] ? T : never;
 export type TagSource = {
@@ -12,12 +11,9 @@ export type TagSource = {
 };
 export declare abstract class BaseProcessor {
     tagSource: TagSource;
-    protected readonly astService: typeof t & {
-        addDefaultImport: (source: string, nameHint?: string) => Identifier;
-        addNamedImport: (name: string, source: string, nameHint?: string) => Identifier;
-    };
+    protected readonly astService: AstService;
     readonly location: SourceLocation | null;
-    protected readonly replacer: (replacement: Expression | ((tagPath: NodePath) => Expression), isPure: boolean) => void;
+    protected readonly replacer: (replacement: Expression | ((tagPath: unknown) => Expression), isPure: boolean) => void;
     readonly displayName: string;
     readonly isReferenced: boolean;
     protected readonly idx: number;
@@ -31,10 +27,7 @@ export declare abstract class BaseProcessor {
     readonly slug: string;
     protected callee: Identifier | MemberExpression;
     protected evaluated: Record<'dependencies' | 'expression', Value[]> | undefined;
-    constructor(params: Params, tagSource: TagSource, astService: typeof t & {
-        addDefaultImport: (source: string, nameHint?: string) => Identifier;
-        addNamedImport: (name: string, source: string, nameHint?: string) => Identifier;
-    }, location: SourceLocation | null, replacer: (replacement: Expression | ((tagPath: NodePath) => Expression), isPure: boolean) => void, displayName: string, isReferenced: boolean, idx: number, options: IOptions, context: IFileContext);
+    constructor(params: Params, tagSource: TagSource, astService: AstService, location: SourceLocation | null, replacer: (replacement: Expression | ((tagPath: unknown) => Expression), isPure: boolean) => void, displayName: string, isReferenced: boolean, idx: number, options: IOptions, context: IFileContext);
     /**
      * A replacement for tag referenced in a template literal.
      */
@@ -45,6 +38,7 @@ export declare abstract class BaseProcessor {
      * whereas `styled` tag will be replaced with an object with metadata.
      */
     abstract get value(): Expression;
+    addDiagnostic(diagnostic: ProcessorDiagnostic): void;
     isValidValue(value: unknown): value is Value;
     toString(): string;
     protected tagSourceCode(): string;

package/types/BaseProcessor.js

@@ -1,15 +1,10 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseProcessor = void 0;
-const generator_1 = __importDefault(require("@babel/generator"));
-const shared_1 = require("@wyw-in-js/shared");
-const getClassNameAndSlug_1 = __importDefault(require("./utils/getClassNameAndSlug"));
-const toCSS_1 = require("./utils/toCSS");
-const validateParams_1 = require("./utils/validateParams");
-class BaseProcessor {
+import { hasEvalMeta } from '@wyw-in-js/shared';
+import { expressionToCode } from './ast';
+import { createProcessorDiagnosticArtifact } from './diagnostics';
+import getClassNameAndSlug from './utils/getClassNameAndSlug';
+import { isCSSable } from './utils/toCSS';
+import { validateParams } from './utils/validateParams';
+export class BaseProcessor {
     tagSource;
     astService;
     location;
@@ -37,23 +32,26 @@ class BaseProcessor {
         this.idx = idx;
         this.options = options;
         this.context = context;
-        (0, validateParams_1.validateParams)(params, ['callee'], 'Unknown error: a callee param is not specified');
-        const { className, slug } = (0, getClassNameAndSlug_1.default)(this.displayName, this.idx, this.options, this.context);
+        validateParams(params, ['callee'], 'Unknown error: a callee param is not specified');
+        const { className, slug } = getClassNameAndSlug(this.displayName, this.idx, this.options, this.context);
         this.className = className;
         this.slug = slug;
         [[, this.callee]] = params;
     }
+    addDiagnostic(diagnostic) {
+        this.artifacts.push(createProcessorDiagnosticArtifact({
+            ...diagnostic,
+            end: diagnostic.end ?? this.location?.end ?? null,
+            start: diagnostic.start ?? this.location?.start ?? null,
+        }));
+    }
     isValidValue(value) {
-        return (typeof value === 'function' || (0, toCSS_1.isCSSable)(value) || (0, shared_1.hasEvalMeta)(value));
+        return (typeof value === 'function' || isCSSable(value) || hasEvalMeta(value));
     }
     toString() {
         return this.tagSourceCode();
     }
     tagSourceCode() {
-        if (this.callee.type === 'Identifier') {
-            return this.callee.name;
-        }
-        return (0, generator_1.default)(this.callee).code;
+        return expressionToCode(this.callee);
     }
 }
-exports.BaseProcessor = BaseProcessor;

package/types/TaggedTemplateProcessor.d.ts

@@ -1,4 +1,4 @@
-import type { Expression, SourceLocation } from '@babel/types';
+import type { Expression, SourceLocation } from './ast';
 import type { TailProcessorParams } from './BaseProcessor';
 import { BaseProcessor } from './BaseProcessor';
 import type { ValueCache, Rules, Params } from './types';

package/types/TaggedTemplateProcessor.js

@@ -1,23 +1,17 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TaggedTemplateProcessor = void 0;
-const shared_1 = require("@wyw-in-js/shared");
-const BaseProcessor_1 = require("./BaseProcessor");
-const templateProcessor_1 = __importDefault(require("./utils/templateProcessor"));
-const validateParams_1 = require("./utils/validateParams");
-class TaggedTemplateProcessor extends BaseProcessor_1.BaseProcessor {
+import { ValueType } from '@wyw-in-js/shared';
+import { BaseProcessor } from './BaseProcessor';
+import templateProcessor from './utils/templateProcessor';
+import { validateParams } from './utils/validateParams';
+export class TaggedTemplateProcessor extends BaseProcessor {
     #template;
     constructor(params, ...args) {
         // Should have at least two params and the first one should be a callee.
-        (0, validateParams_1.validateParams)(params, ['callee', '...'], TaggedTemplateProcessor.SKIP);
-        (0, validateParams_1.validateParams)(params, ['callee', 'template'], 'Invalid usage of template tag');
+        validateParams(params, ['callee', '...'], TaggedTemplateProcessor.SKIP);
+        validateParams(params, ['callee', 'template'], 'Invalid usage of template tag');
         const [tag, [, template]] = params;
         super([tag], ...args);
         template.forEach((element) => {
-            if ('kind' in element && element.kind !== shared_1.ValueType.FUNCTION) {
+            if ('kind' in element && element.kind !== ValueType.FUNCTION) {
                 this.dependencies.push(element);
             }
         });
@@ -28,7 +22,7 @@ class TaggedTemplateProcessor extends BaseProcessor_1.BaseProcessor {
             // FIXME: why it was called twice?
             throw new Error('Tag is already built');
         }
-        const artifact = (0, templateProcessor_1.default)(this, this.#template, values, this.options.variableNameConfig);
+        const artifact = templateProcessor(this, this.#template, values, this.options.variableNameConfig);
         if (artifact) {
             this.artifacts.push(['css', artifact]);
         }
@@ -37,4 +31,3 @@ class TaggedTemplateProcessor extends BaseProcessor_1.BaseProcessor {
         return `${super.toString()}\`…\``;
     }
 }
-exports.TaggedTemplateProcessor = TaggedTemplateProcessor;

package/types/ast.d.ts

@@ -0,0 +1,95 @@
+import type { Location } from '@wyw-in-js/shared';
+export type SourceLocation = {
+    end: Location;
+    filename?: string;
+    identifierName?: string | null;
+    start: Location;
+};
+export type BaseAstNode = {
+    end?: number | null;
+    loc?: unknown;
+    start?: number | null;
+    type: string;
+};
+export type Expression = BaseAstNode;
+export type Identifier = Expression & {
+    name: string;
+    type: 'Identifier';
+};
+export type StringLiteral = Expression & {
+    type: 'StringLiteral';
+    value: string;
+};
+export type NumericLiteral = Expression & {
+    type: 'NumericLiteral';
+    value: number;
+};
+export type BooleanLiteral = Expression & {
+    type: 'BooleanLiteral';
+    value: boolean;
+};
+export type NullLiteral = Expression & {
+    type: 'NullLiteral';
+};
+export type BlockStatement = BaseAstNode & {
+    body: BaseAstNode[];
+    type: 'BlockStatement';
+};
+export type TemplateElement = BaseAstNode & {
+    loc?: SourceLocation | null;
+    tail: boolean;
+    type: 'TemplateElement';
+    value: {
+        cooked?: string | null;
+        raw: string;
+    };
+};
+export type MemberExpression = Expression & {
+    computed?: boolean;
+    object: Expression;
+    property: Expression;
+    type: 'MemberExpression';
+};
+export type ObjectProperty = BaseAstNode & {
+    computed?: boolean;
+    key: Expression;
+    shorthand?: boolean;
+    type: 'ObjectProperty';
+    value: Expression;
+};
+export type ObjectExpression = Expression & {
+    properties: ObjectProperty[];
+    type: 'ObjectExpression';
+};
+export type ArrayExpression = Expression & {
+    elements: (Expression | null)[];
+    type: 'ArrayExpression';
+};
+export type CallExpression = Expression & {
+    arguments: Expression[];
+    callee: Expression;
+    type: 'CallExpression';
+};
+export type ArrowFunctionExpression = Expression & {
+    async?: boolean;
+    body: BlockStatement | Expression;
+    params: Identifier[];
+    type: 'ArrowFunctionExpression';
+};
+export type AstService = {
+    addDefaultImport(source: string, nameHint?: string): Identifier;
+    addNamedImport(name: string, source: string, nameHint?: string): Identifier;
+    arrayExpression(elements: (Expression | null)[]): ArrayExpression;
+    arrowFunctionExpression(params: Identifier[], body: BlockStatement | Expression): ArrowFunctionExpression;
+    blockStatement(body: BaseAstNode[]): BlockStatement;
+    booleanLiteral(value: boolean): BooleanLiteral;
+    callExpression(callee: Expression, args: Expression[]): CallExpression;
+    identifier(name: string): Identifier;
+    memberExpression(object: Expression, property: Expression, computed?: boolean): MemberExpression;
+    nullLiteral(): NullLiteral;
+    numericLiteral(value: number): NumericLiteral;
+    objectExpression(properties: ObjectProperty[]): ObjectExpression;
+    objectProperty(key: Expression, value: Expression): ObjectProperty;
+    stringLiteral(value: string): StringLiteral;
+};
+export declare const expressionToCode: (expression: Expression) => string;

package/types/ast.js

@@ -0,0 +1,80 @@
+const stringLiteralCode = (value, quote = 'double') => {
+    const json = JSON.stringify(value);
+    if (quote === 'double') {
+        return json;
+    }
+    return `'${json.slice(1, -1).replace(/'/g, "\\'")}'`;
+};
+const indent = (level) => '  '.repeat(level);
+const expressionToCodeWithContext = (expression, context) => {
+    if (expression.type === 'Identifier') {
+        return expression.name;
+    }
+    if (expression.type === 'StringLiteral') {
+        return stringLiteralCode(expression.value, context.quote);
+    }
+    if (expression.type === 'NumericLiteral' ||
+        expression.type === 'BooleanLiteral') {
+        return String(expression.value);
+    }
+    if (expression.type === 'NullLiteral') {
+        return 'null';
+    }
+    if (expression.type === 'MemberExpression') {
+        const memberExpression = expression;
+        const object = expressionToCodeWithContext(memberExpression.object, context);
+        const property = expressionToCodeWithContext(memberExpression.property, context);
+        return memberExpression.computed
+            ? `${object}[${property}]`
+            : `${object}.${property}`;
+    }
+    if (expression.type === 'CallExpression') {
+        const callExpression = expression;
+        const callee = expressionToCodeWithContext(callExpression.callee, context);
+        const args = callExpression.arguments.map((arg) => expressionToCodeWithContext(arg, {
+            ...context,
+            quote: arg.type === 'StringLiteral' ? 'single' : context.quote,
+        }));
+        return `${callee}(${args.join(', ')})`;
+    }
+    if (expression.type === 'ArrowFunctionExpression') {
+        const arrow = expression;
+        return `(${arrow.params
+            .map((param) => expressionToCodeWithContext(param, context))
+            .join(', ')}) => ${expressionToCodeWithContext(arrow.body, context)}`;
+    }
+    if (expression.type === 'ArrayExpression') {
+        return `[${expression.elements
+            .map((item) => item ? expressionToCodeWithContext(item, context) : '')
+            .join(', ')}]`;
+    }
+    if (expression.type === 'BlockStatement') {
+        return '{ }';
+    }
+    if (expression.type === 'ObjectExpression') {
+        const objectExpression = expression;
+        if (objectExpression.properties.length === 0) {
+            return '{}';
+        }
+        const nextIndent = context.indent + 1;
+        const properties = objectExpression.properties
+            .map((property) => {
+            const key = expressionToCodeWithContext(property.key, {
+                ...context,
+                quote: 'double',
+            });
+            const value = expressionToCodeWithContext(property.value, {
+                indent: nextIndent,
+                quote: 'double',
+            });
+            return `${indent(nextIndent)}${key}: ${value}`;
+        })
+            .join(',\n');
+        return `{\n${properties}\n${indent(context.indent)}}`;
+    }
+    return expression.type;
+};
+export const expressionToCode = (expression) => expressionToCodeWithContext(expression, {
+    indent: 0,
+    quote: 'double',
+});

package/types/diagnostics.d.ts

@@ -0,0 +1,9 @@
+import type { Artifact } from '@wyw-in-js/shared';
+import type { ProcessorDiagnostic } from './types';
+export declare const PROCESSOR_DIAGNOSTIC_ARTIFACT: "wyw-in-js:diagnostic";
+export type ProcessorDiagnosticArtifact = [
+    name: typeof PROCESSOR_DIAGNOSTIC_ARTIFACT,
+    data: ProcessorDiagnostic
+];
+export declare const createProcessorDiagnosticArtifact: (diagnostic: ProcessorDiagnostic) => ProcessorDiagnosticArtifact;
+export declare const isProcessorDiagnosticArtifact: (artifact: Artifact) => artifact is ProcessorDiagnosticArtifact;

package/types/diagnostics.js

@@ -0,0 +1,3 @@
+export const PROCESSOR_DIAGNOSTIC_ARTIFACT = 'wyw-in-js:diagnostic';
+export const createProcessorDiagnosticArtifact = (diagnostic) => [PROCESSOR_DIAGNOSTIC_ARTIFACT, diagnostic];
+export const isProcessorDiagnosticArtifact = (artifact) => artifact[0] === PROCESSOR_DIAGNOSTIC_ARTIFACT;

package/types/index.d.ts

@@ -1,5 +1,9 @@
 export { BaseProcessor } from './BaseProcessor';
-export type { Expression, TagSource, ProcessorParams, TailProcessorParams, } from './BaseProcessor';
+export { expressionToCode } from './ast';
+export { createProcessorDiagnosticArtifact, isProcessorDiagnosticArtifact, PROCESSOR_DIAGNOSTIC_ARTIFACT, } from './diagnostics';
+export type { ProcessorDiagnosticArtifact } from './diagnostics';
+export type { ArrayExpression, ArrowFunctionExpression, AstService, BaseAstNode, BlockStatement, BooleanLiteral, CallExpression, Expression, Identifier, MemberExpression, NullLiteral, NumericLiteral, ObjectExpression, ObjectProperty, SourceLocation, StringLiteral, TemplateElement, } from './ast';
+export type { ProcessorParams, TagSource, TailProcessorParams, } from './BaseProcessor';
 export * from './types';
 export { buildSlug } from './utils/buildSlug';
 export type { IOptions, IFileContext } from './utils/types';

package/types/index.js

@@ -1,29 +1,8 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toValidCSSIdentifier = exports.TaggedTemplateProcessor = exports.validateParams = exports.isValidParams = exports.buildSlug = exports.BaseProcessor = void 0;
-var BaseProcessor_1 = require("./BaseProcessor");
-Object.defineProperty(exports, "BaseProcessor", { enumerable: true, get: function () { return BaseProcessor_1.BaseProcessor; } });
-__exportStar(require("./types"), exports);
-var buildSlug_1 = require("./utils/buildSlug");
-Object.defineProperty(exports, "buildSlug", { enumerable: true, get: function () { return buildSlug_1.buildSlug; } });
-var validateParams_1 = require("./utils/validateParams");
-Object.defineProperty(exports, "isValidParams", { enumerable: true, get: function () { return validateParams_1.isValidParams; } });
-Object.defineProperty(exports, "validateParams", { enumerable: true, get: function () { return validateParams_1.validateParams; } });
-var TaggedTemplateProcessor_1 = require("./TaggedTemplateProcessor");
-Object.defineProperty(exports, "TaggedTemplateProcessor", { enumerable: true, get: function () { return TaggedTemplateProcessor_1.TaggedTemplateProcessor; } });
-var toValidCSSIdentifier_1 = require("./utils/toValidCSSIdentifier");
-Object.defineProperty(exports, "toValidCSSIdentifier", { enumerable: true, get: function () { return toValidCSSIdentifier_1.toValidCSSIdentifier; } });
+export { BaseProcessor } from './BaseProcessor';
+export { expressionToCode } from './ast';
+export { createProcessorDiagnosticArtifact, isProcessorDiagnosticArtifact, PROCESSOR_DIAGNOSTIC_ARTIFACT, } from './diagnostics';
+export * from './types';
+export { buildSlug } from './utils/buildSlug';
+export { isValidParams, validateParams } from './utils/validateParams';
+export { TaggedTemplateProcessor } from './TaggedTemplateProcessor';
+export { toValidCSSIdentifier } from './utils/toValidCSSIdentifier';

package/types/types.d.ts

@@ -1,5 +1,5 @@
-import type { Expression, Identifier, TemplateElement, MemberExpression } from '@babel/types';
 import type { ExpressionValue, Location, WYWEvalMeta } from '@wyw-in-js/shared';
+import type { Expression, Identifier, MemberExpression, TemplateElement } from './ast';
 export type CSSPropertyValue = string | number;
 export type ObjectWithSelectors = {
     [key: string]: ObjectWithSelectors | CSSPropertyValue | (ObjectWithSelectors | CSSPropertyValue)[];
@@ -20,6 +20,14 @@ export interface IInterpolation {
     source: string;
     unit: string;
 }
+export type ProcessorDiagnosticSeverity = 'error' | 'warning';
+export type ProcessorDiagnostic = {
+    category: string;
+    end?: Location | null;
+    message: string;
+    severity: ProcessorDiagnosticSeverity;
+    start?: Location | null;
+};
 export type Rules = Record<string, ICSSRule>;
 export type CalleeParam = readonly ['callee', Identifier | MemberExpression];
 export type CallParam = readonly ['call', ...ExpressionValue[]];

package/types/types.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/types/utils/buildSlug.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildSlug = buildSlug;
 const PLACEHOLDER = /\[(.*?)]/g;
 const isValidArgName = (key, args) => key in args;
-function buildSlug(pattern, args) {
+export function buildSlug(pattern, args) {
     return pattern.replace(PLACEHOLDER, (_, name) => isValidArgName(name, args) ? args[name].toString() : '');
 }