@wyw-in-js/processor-utils 0.1.0

package/lib/utils/throwIfInvalid.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const isLikeError = value => typeof value === 'object' && value !== null && 'stack' in value && 'message' in value;
+
+// Throw if we can't handle the interpolated value
+function throwIfInvalid(checker, value, ex, source) {
+  // We can't use instanceof here so let's use duck typing
+  if (isLikeError(value) && value.stack && value.message) {
+    throw ex.buildCodeFrameError(`An error occurred when evaluating the expression:
+
+  > ${value.message}.
+
+  Make sure you are not using a browser or Node specific API and all the variables are available in static context.
+  Linaria have to extract pieces of your code to resolve the interpolated values.
+  Defining styled component or class will not work inside:
+    - function,
+    - class,
+    - method,
+    - loop,
+  because it cannot be statically determined in which context you use them.
+  That's why some variables may be not defined during evaluation.
+      `);
+  }
+  if (checker(value)) {
+    return;
+  }
+  const stringified = typeof value === 'object' ? JSON.stringify(value) : String(value);
+  throw ex.buildCodeFrameError(`The expression evaluated to '${stringified}', which is probably a mistake. If you want it to be inserted into CSS, explicitly cast or transform the value to a string, e.g. - 'String(${source})'.`);
+}
+var _default = exports.default = throwIfInvalid;
+//# sourceMappingURL=throwIfInvalid.js.map

package/lib/utils/throwIfInvalid.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"throwIfInvalid.js","names":["isLikeError","value","throwIfInvalid","checker","ex","source","stack","message","buildCodeFrameError","stringified","JSON","stringify","String","_default","exports","default"],"sources":["../../src/utils/throwIfInvalid.ts"],"sourcesContent":["import type { BuildCodeFrameErrorFn } from '@wyw-in-js/shared';\n\nconst isLikeError = (value: unknown): value is Error =>\n  typeof value === 'object' &&\n  value !== null &&\n  'stack' in value &&\n  'message' in value;\n\n// Throw if we can't handle the interpolated value\nfunction throwIfInvalid<T>(\n  checker: (value: unknown) => value is T,\n  value: Error | unknown,\n  ex: { buildCodeFrameError: BuildCodeFrameErrorFn },\n  source: string\n): asserts value is T {\n  // We can't use instanceof here so let's use duck typing\n  if (isLikeError(value) && value.stack && value.message) {\n    throw ex.buildCodeFrameError(\n      `An error occurred when evaluating the expression:\n\n  > ${value.message}.\n\n  Make sure you are not using a browser or Node specific API and all the variables are available in static context.\n  Linaria have to extract pieces of your code to resolve the interpolated values.\n  Defining styled component or class will not work inside:\n    - function,\n    - class,\n    - method,\n    - loop,\n  because it cannot be statically determined in which context you use them.\n  That's why some variables may be not defined during evaluation.\n      `\n    );\n  }\n\n  if (checker(value)) {\n    return;\n  }\n\n  const stringified =\n    typeof value === 'object' ? JSON.stringify(value) : String(value);\n\n  throw ex.buildCodeFrameError(\n    `The expression evaluated to '${stringified}', which is probably a mistake. If you want it to be inserted into CSS, explicitly cast or transform the value to a string, e.g. - 'String(${source})'.`\n  );\n}\n\nexport default throwIfInvalid;\n"],"mappings":";;;;;;AAEA,MAAMA,WAAW,GAAIC,KAAc,IACjC,OAAOA,KAAK,KAAK,QAAQ,IACzBA,KAAK,KAAK,IAAI,IACd,OAAO,IAAIA,KAAK,IAChB,SAAS,IAAIA,KAAK;;AAEpB;AACA,SAASC,cAAcA,CACrBC,OAAuC,EACvCF,KAAsB,EACtBG,EAAkD,EAClDC,MAAc,EACM;EACpB;EACA,IAAIL,WAAW,CAACC,KAAK,CAAC,IAAIA,KAAK,CAACK,KAAK,IAAIL,KAAK,CAACM,OAAO,EAAE;IACtD,MAAMH,EAAE,CAACI,mBAAmB,CACzB;AACP;AACA,MAAMP,KAAK,CAACM,OAAQ;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OACI,CAAC;EACH;EAEA,IAAIJ,OAAO,CAACF,KAAK,CAAC,EAAE;IAClB;EACF;EAEA,MAAMQ,WAAW,GACf,OAAOR,KAAK,KAAK,QAAQ,GAAGS,IAAI,CAACC,SAAS,CAACV,KAAK,CAAC,GAAGW,MAAM,CAACX,KAAK,CAAC;EAEnE,MAAMG,EAAE,CAACI,mBAAmB,CACzB,gCAA+BC,WAAY,8IAA6IJ,MAAO,KAClM,CAAC;AACH;AAAC,IAAAQ,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAEcb,cAAc"}

package/lib/utils/toCSS.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = toCSS;
+exports.isCSSable = void 0;
+var _shared = require("@wyw-in-js/shared");
+var _units = require("./units");
+const isCSSPropertyValue = o => {
+  return (0, _shared.isBoxedPrimitive)(o) || typeof o === 'string' || typeof o === 'number' && Number.isFinite(o);
+};
+const isCSSable = o => {
+  if (isCSSPropertyValue(o)) {
+    return true;
+  }
+  if (Array.isArray(o)) {
+    return o.every(isCSSable);
+  }
+  if (typeof o === 'object') {
+    return o !== null && Object.values(o).every(isCSSable);
+  }
+  return false;
+};
+exports.isCSSable = isCSSable;
+const hyphenate = s => {
+  if (s.startsWith('--')) {
+    // It's a custom property which is already well formatted.
+    return s;
+  }
+  return s
+  // Hyphenate CSS property names from camelCase version from JS string
+  .replace(/([A-Z])/g, (match, p1) => `-${p1.toLowerCase()}`)
+  // Special case for `-ms` because in JS it starts with `ms` unlike `Webkit`
+  .replace(/^ms-/, '-ms-');
+};
+
+// Some tools such as polished.js output JS objects
+// To support them transparently, we convert JS objects to CSS strings
+function toCSS(o) {
+  if (Array.isArray(o)) {
+    return o.map(toCSS).join('\n');
+  }
+  if (isCSSPropertyValue(o)) {
+    return o.valueOf().toString();
+  }
+  return Object.entries(o).filter(([, value]) =>
+  // Ignore all falsy values except numbers
+  typeof value === 'number' || value).map(([key, value]) => {
+    if (!isCSSPropertyValue(value)) {
+      return `${key} { ${toCSS(value)} }`;
+    }
+    return `${hyphenate(key)}: ${typeof value === 'number' && value !== 0 &&
+    // Strip vendor prefixes when checking if the value is unitless
+    !(key.replace(/^(Webkit|Moz|O|ms)([A-Z])(.+)$/, (match, p1, p2, p3) => `${p2.toLowerCase()}${p3}`) in _units.unitless) ? `${value}px` : value};`;
+  }).join(' ');
+}
+//# sourceMappingURL=toCSS.js.map

package/lib/utils/toCSS.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toCSS.js","names":["_shared","require","_units","isCSSPropertyValue","o","isBoxedPrimitive","Number","isFinite","isCSSable","Array","isArray","every","Object","values","exports","hyphenate","s","startsWith","replace","match","p1","toLowerCase","toCSS","map","join","valueOf","toString","entries","filter","value","key","p2","p3","unitless"],"sources":["../../src/utils/toCSS.ts"],"sourcesContent":["import { isBoxedPrimitive } from '@wyw-in-js/shared';\n\nimport type { CSSPropertyValue, CSSable } from '../types';\n\nimport { unitless } from './units';\n\nconst isCSSPropertyValue = (o: unknown): o is CSSPropertyValue => {\n  return (\n    isBoxedPrimitive(o) ||\n    typeof o === 'string' ||\n    (typeof o === 'number' && Number.isFinite(o))\n  );\n};\n\nexport const isCSSable = (o: unknown): o is CSSable => {\n  if (isCSSPropertyValue(o)) {\n    return true;\n  }\n\n  if (Array.isArray(o)) {\n    return o.every(isCSSable);\n  }\n\n  if (typeof o === 'object') {\n    return o !== null && Object.values(o).every(isCSSable);\n  }\n\n  return false;\n};\n\nconst hyphenate = (s: string) => {\n  if (s.startsWith('--')) {\n    // It's a custom property which is already well formatted.\n    return s;\n  }\n  return (\n    s\n      // Hyphenate CSS property names from camelCase version from JS string\n      .replace(/([A-Z])/g, (match, p1) => `-${p1.toLowerCase()}`)\n      // Special case for `-ms` because in JS it starts with `ms` unlike `Webkit`\n      .replace(/^ms-/, '-ms-')\n  );\n};\n\n// Some tools such as polished.js output JS objects\n// To support them transparently, we convert JS objects to CSS strings\nexport default function toCSS(o: CSSable): string {\n  if (Array.isArray(o)) {\n    return o.map(toCSS).join('\\n');\n  }\n\n  if (isCSSPropertyValue(o)) {\n    return o.valueOf().toString();\n  }\n\n  return Object.entries(o)\n    .filter(\n      ([, value]) =>\n        // Ignore all falsy values except numbers\n        typeof value === 'number' || value\n    )\n    .map(([key, value]) => {\n      if (!isCSSPropertyValue(value)) {\n        return `${key} { ${toCSS(value)} }`;\n      }\n\n      return `${hyphenate(key)}: ${\n        typeof value === 'number' &&\n        value !== 0 &&\n        // Strip vendor prefixes when checking if the value is unitless\n        !(\n          key.replace(\n            /^(Webkit|Moz|O|ms)([A-Z])(.+)$/,\n            (match, p1, p2, p3) => `${p2.toLowerCase()}${p3}`\n          ) in unitless\n        )\n          ? `${value}px`\n          : value\n      };`;\n    })\n    .join(' ');\n}\n"],"mappings":";;;;;;;AAAA,IAAAA,OAAA,GAAAC,OAAA;AAIA,IAAAC,MAAA,GAAAD,OAAA;AAEA,MAAME,kBAAkB,GAAIC,CAAU,IAA4B;EAChE,OACE,IAAAC,wBAAgB,EAACD,CAAC,CAAC,IACnB,OAAOA,CAAC,KAAK,QAAQ,IACpB,OAAOA,CAAC,KAAK,QAAQ,IAAIE,MAAM,CAACC,QAAQ,CAACH,CAAC,CAAE;AAEjD,CAAC;AAEM,MAAMI,SAAS,GAAIJ,CAAU,IAAmB;EACrD,IAAID,kBAAkB,CAACC,CAAC,CAAC,EAAE;IACzB,OAAO,IAAI;EACb;EAEA,IAAIK,KAAK,CAACC,OAAO,CAACN,CAAC,CAAC,EAAE;IACpB,OAAOA,CAAC,CAACO,KAAK,CAACH,SAAS,CAAC;EAC3B;EAEA,IAAI,OAAOJ,CAAC,KAAK,QAAQ,EAAE;IACzB,OAAOA,CAAC,KAAK,IAAI,IAAIQ,MAAM,CAACC,MAAM,CAACT,CAAC,CAAC,CAACO,KAAK,CAACH,SAAS,CAAC;EACxD;EAEA,OAAO,KAAK;AACd,CAAC;AAACM,OAAA,CAAAN,SAAA,GAAAA,SAAA;AAEF,MAAMO,SAAS,GAAIC,CAAS,IAAK;EAC/B,IAAIA,CAAC,CAACC,UAAU,CAAC,IAAI,CAAC,EAAE;IACtB;IACA,OAAOD,CAAC;EACV;EACA,OACEA;EACE;EAAA,CACCE,OAAO,CAAC,UAAU,EAAE,CAACC,KAAK,EAAEC,EAAE,KAAM,IAAGA,EAAE,CAACC,WAAW,CAAC,CAAE,EAAC;EAC1D;EAAA,CACCH,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC;AAE9B,CAAC;;AAED;AACA;AACe,SAASI,KAAKA,CAAClB,CAAU,EAAU;EAChD,IAAIK,KAAK,CAACC,OAAO,CAACN,CAAC,CAAC,EAAE;IACpB,OAAOA,CAAC,CAACmB,GAAG,CAACD,KAAK,CAAC,CAACE,IAAI,CAAC,IAAI,CAAC;EAChC;EAEA,IAAIrB,kBAAkB,CAACC,CAAC,CAAC,EAAE;IACzB,OAAOA,CAAC,CAACqB,OAAO,CAAC,CAAC,CAACC,QAAQ,CAAC,CAAC;EAC/B;EAEA,OAAOd,MAAM,CAACe,OAAO,CAACvB,CAAC,CAAC,CACrBwB,MAAM,CACL,CAAC,GAAGC,KAAK,CAAC;EACR;EACA,OAAOA,KAAK,KAAK,QAAQ,IAAIA,KACjC,CAAC,CACAN,GAAG,CAAC,CAAC,CAACO,GAAG,EAAED,KAAK,CAAC,KAAK;IACrB,IAAI,CAAC1B,kBAAkB,CAAC0B,KAAK,CAAC,EAAE;MAC9B,OAAQ,GAAEC,GAAI,MAAKR,KAAK,CAACO,KAAK,CAAE,IAAG;IACrC;IAEA,OAAQ,GAAEd,SAAS,CAACe,GAAG,CAAE,KACvB,OAAOD,KAAK,KAAK,QAAQ,IACzBA,KAAK,KAAK,CAAC;IACX;IACA,EACEC,GAAG,CAACZ,OAAO,CACT,gCAAgC,EAChC,CAACC,KAAK,EAAEC,EAAE,EAAEW,EAAE,EAAEC,EAAE,KAAM,GAAED,EAAE,CAACV,WAAW,CAAC,CAAE,GAAEW,EAAG,EAClD,CAAC,IAAIC,eAAQ,CACd,GACI,GAAEJ,KAAM,IAAG,GACZA,KACL,GAAE;EACL,CAAC,CAAC,CACDL,IAAI,CAAC,GAAG,CAAC;AACd"}

package/lib/utils/toValidCSSIdentifier.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toValidCSSIdentifier = toValidCSSIdentifier;
+function toValidCSSIdentifier(s) {
+  return s.replace(/[^-_a-z0-9\u00A0-\uFFFF]/gi, '_').replace(/^\d/, '_');
+}
+//# sourceMappingURL=toValidCSSIdentifier.js.map

package/lib/utils/toValidCSSIdentifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toValidCSSIdentifier.js","names":["toValidCSSIdentifier","s","replace"],"sources":["../../src/utils/toValidCSSIdentifier.ts"],"sourcesContent":["export function toValidCSSIdentifier(s: string) {\n  return s.replace(/[^-_a-z0-9\\u00A0-\\uFFFF]/gi, '_').replace(/^\\d/, '_');\n}\n"],"mappings":";;;;;;AAAO,SAASA,oBAAoBA,CAACC,CAAS,EAAE;EAC9C,OAAOA,CAAC,CAACC,OAAO,CAAC,4BAA4B,EAAE,GAAG,CAAC,CAACA,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC;AACzE"}

package/lib/utils/types.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=types.js.map

package/lib/utils/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../src/utils/types.ts"],"sourcesContent":["import type { TransformOptions } from '@babel/core';\n\nimport type { ClassNameFn, VariableNameFn } from '@wyw-in-js/shared';\n\nexport interface IOptions {\n  classNameSlug?: string | ClassNameFn;\n  displayName: boolean;\n  variableNameConfig?: 'var' | 'dashes' | 'raw';\n  variableNameSlug?: string | VariableNameFn;\n}\n\nexport type IFileContext = Pick<TransformOptions, 'root' | 'filename'>;\n"],"mappings":""}

package/lib/utils/units.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.units = exports.unitless = void 0;
+// https://www.w3.org/TR/css-values-4/
+const units = exports.units = [
+// font relative lengths
+'em', 'ex', 'cap', 'ch', 'ic', 'rem', 'lh', 'rlh',
+// viewport percentage lengths
+'vw', 'vh', 'vi', 'vb', 'vmin', 'vmax',
+// absolute lengths
+'cm', 'mm', 'Q', 'in', 'pc', 'pt', 'px',
+// angle units
+'deg', 'grad', 'rad', 'turn',
+// duration units
+'s', 'ms',
+// frequency units
+'Hz', 'kHz',
+// resolution units
+'dpi', 'dpcm', 'dppx', 'x',
+// https://www.w3.org/TR/css-grid-1/#fr-unit
+'fr',
+// percentages
+'%'];
+const unitless = exports.unitless = {
+  animationIterationCount: true,
+  borderImageOutset: true,
+  borderImageSlice: true,
+  borderImageWidth: true,
+  boxFlex: true,
+  boxFlexGroup: true,
+  boxOrdinalGroup: true,
+  columnCount: true,
+  columns: true,
+  flex: true,
+  flexGrow: true,
+  flexPositive: true,
+  flexShrink: true,
+  flexNegative: true,
+  flexOrder: true,
+  gridRow: true,
+  gridRowEnd: true,
+  gridRowSpan: true,
+  gridRowStart: true,
+  gridColumn: true,
+  gridColumnEnd: true,
+  gridColumnSpan: true,
+  gridColumnStart: true,
+  fontWeight: true,
+  lineClamp: true,
+  lineHeight: true,
+  opacity: true,
+  order: true,
+  orphans: true,
+  tabSize: true,
+  widows: true,
+  zIndex: true,
+  zoom: true,
+  // SVG-related properties
+  fillOpacity: true,
+  floodOpacity: true,
+  stopOpacity: true,
+  strokeDasharray: true,
+  strokeDashoffset: true,
+  strokeMiterlimit: true,
+  strokeOpacity: true,
+  strokeWidth: true
+};
+//# sourceMappingURL=units.js.map

package/lib/utils/units.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"units.js","names":["units","exports","unitless","animationIterationCount","borderImageOutset","borderImageSlice","borderImageWidth","boxFlex","boxFlexGroup","boxOrdinalGroup","columnCount","columns","flex","flexGrow","flexPositive","flexShrink","flexNegative","flexOrder","gridRow","gridRowEnd","gridRowSpan","gridRowStart","gridColumn","gridColumnEnd","gridColumnSpan","gridColumnStart","fontWeight","lineClamp","lineHeight","opacity","order","orphans","tabSize","widows","zIndex","zoom","fillOpacity","floodOpacity","stopOpacity","strokeDasharray","strokeDashoffset","strokeMiterlimit","strokeOpacity","strokeWidth"],"sources":["../../src/utils/units.ts"],"sourcesContent":["// https://www.w3.org/TR/css-values-4/\nexport const units = [\n  // font relative lengths\n  'em',\n  'ex',\n  'cap',\n  'ch',\n  'ic',\n  'rem',\n  'lh',\n  'rlh',\n\n  // viewport percentage lengths\n  'vw',\n  'vh',\n  'vi',\n  'vb',\n  'vmin',\n  'vmax',\n\n  // absolute lengths\n  'cm',\n  'mm',\n  'Q',\n  'in',\n  'pc',\n  'pt',\n  'px',\n\n  // angle units\n  'deg',\n  'grad',\n  'rad',\n  'turn',\n\n  // duration units\n  's',\n  'ms',\n\n  // frequency units\n  'Hz',\n  'kHz',\n\n  // resolution units\n  'dpi',\n  'dpcm',\n  'dppx',\n  'x',\n\n  // https://www.w3.org/TR/css-grid-1/#fr-unit\n  'fr',\n\n  // percentages\n  '%',\n];\n\nexport const unitless = {\n  animationIterationCount: true,\n  borderImageOutset: true,\n  borderImageSlice: true,\n  borderImageWidth: true,\n  boxFlex: true,\n  boxFlexGroup: true,\n  boxOrdinalGroup: true,\n  columnCount: true,\n  columns: true,\n  flex: true,\n  flexGrow: true,\n  flexPositive: true,\n  flexShrink: true,\n  flexNegative: true,\n  flexOrder: true,\n  gridRow: true,\n  gridRowEnd: true,\n  gridRowSpan: true,\n  gridRowStart: true,\n  gridColumn: true,\n  gridColumnEnd: true,\n  gridColumnSpan: true,\n  gridColumnStart: true,\n  fontWeight: true,\n  lineClamp: true,\n  lineHeight: true,\n  opacity: true,\n  order: true,\n  orphans: true,\n  tabSize: true,\n  widows: true,\n  zIndex: true,\n  zoom: true,\n\n  // SVG-related properties\n  fillOpacity: true,\n  floodOpacity: true,\n  stopOpacity: true,\n  strokeDasharray: true,\n  strokeDashoffset: true,\n  strokeMiterlimit: true,\n  strokeOpacity: true,\n  strokeWidth: true,\n};\n"],"mappings":";;;;;;AAAA;AACO,MAAMA,KAAK,GAAAC,OAAA,CAAAD,KAAA,GAAG;AACnB;AACA,IAAI,EACJ,IAAI,EACJ,KAAK,EACL,IAAI,EACJ,IAAI,EACJ,KAAK,EACL,IAAI,EACJ,KAAK;AAEL;AACA,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,MAAM,EACN,MAAM;AAEN;AACA,IAAI,EACJ,IAAI,EACJ,GAAG,EACH,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI;AAEJ;AACA,KAAK,EACL,MAAM,EACN,KAAK,EACL,MAAM;AAEN;AACA,GAAG,EACH,IAAI;AAEJ;AACA,IAAI,EACJ,KAAK;AAEL;AACA,KAAK,EACL,MAAM,EACN,MAAM,EACN,GAAG;AAEH;AACA,IAAI;AAEJ;AACA,GAAG,CACJ;AAEM,MAAME,QAAQ,GAAAD,OAAA,CAAAC,QAAA,GAAG;EACtBC,uBAAuB,EAAE,IAAI;EAC7BC,iBAAiB,EAAE,IAAI;EACvBC,gBAAgB,EAAE,IAAI;EACtBC,gBAAgB,EAAE,IAAI;EACtBC,OAAO,EAAE,IAAI;EACbC,YAAY,EAAE,IAAI;EAClBC,eAAe,EAAE,IAAI;EACrBC,WAAW,EAAE,IAAI;EACjBC,OAAO,EAAE,IAAI;EACbC,IAAI,EAAE,IAAI;EACVC,QAAQ,EAAE,IAAI;EACdC,YAAY,EAAE,IAAI;EAClBC,UAAU,EAAE,IAAI;EAChBC,YAAY,EAAE,IAAI;EAClBC,SAAS,EAAE,IAAI;EACfC,OAAO,EAAE,IAAI;EACbC,UAAU,EAAE,IAAI;EAChBC,WAAW,EAAE,IAAI;EACjBC,YAAY,EAAE,IAAI;EAClBC,UAAU,EAAE,IAAI;EAChBC,aAAa,EAAE,IAAI;EACnBC,cAAc,EAAE,IAAI;EACpBC,eAAe,EAAE,IAAI;EACrBC,UAAU,EAAE,IAAI;EAChBC,SAAS,EAAE,IAAI;EACfC,UAAU,EAAE,IAAI;EAChBC,OAAO,EAAE,IAAI;EACbC,KAAK,EAAE,IAAI;EACXC,OAAO,EAAE,IAAI;EACbC,OAAO,EAAE,IAAI;EACbC,MAAM,EAAE,IAAI;EACZC,MAAM,EAAE,IAAI;EACZC,IAAI,EAAE,IAAI;EAEV;EACAC,WAAW,EAAE,IAAI;EACjBC,YAAY,EAAE,IAAI;EAClBC,WAAW,EAAE,IAAI;EACjBC,eAAe,EAAE,IAAI;EACrBC,gBAAgB,EAAE,IAAI;EACtBC,gBAAgB,EAAE,IAAI;EACtBC,aAAa,EAAE,IAAI;EACnBC,WAAW,EAAE;AACf,CAAC"}

package/lib/utils/validateParams.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isValidParams = isValidParams;
+exports.validateParams = validateParams;
+// 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.
+
+function isValidParams(params, constraints) {
+  const length = Math.max(params.length, constraints.length);
+  for (let i = 0; i < length; i++) {
+    var _params$i2;
+    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 => {
+        var _params$i;
+        return c !== ((_params$i = params[i]) === null || _params$i === void 0 ? void 0 : _params$i[0]);
+      })) {
+        return false;
+      }
+    } else if (constraint !== ((_params$i2 = params[i]) === null || _params$i2 === void 0 ? void 0 : _params$i2[0])) {
+      return false;
+    }
+  }
+  return true;
+}
+function validateParams(params, constraints, messageOrError) {
+  if (!isValidParams(params, constraints)) {
+    if (typeof messageOrError === 'string') {
+      throw new Error(messageOrError);
+    }
+    throw messageOrError;
+  }
+}
+//# sourceMappingURL=validateParams.js.map

package/lib/utils/validateParams.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateParams.js","names":["isValidParams","params","constraints","length","Math","max","i","_params$i2","undefined","constraint","Array","isArray","every","c","_params$i","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;;AAEH,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;IAAA,IAAAC,UAAA;IAC/B,IAAIN,MAAM,CAACK,CAAC,CAAC,KAAKE,SAAS,IAAIN,WAAW,CAACI,CAAC,CAAC,KAAKE,SAAS,EAAE;MAC3D,OAAO,KAAK;IACd;IAEA,MAAMC,UAAU,GAAGP,WAAW,CAACI,CAAC,CAAC;IACjC,IAAIG,UAAU,KAAK,KAAK,EAAE;MACxB,OAAO,IAAI;IACb;IAEA,IAAIA,UAAU,KAAK,GAAG,EAAE;MACtB,IAAIR,MAAM,CAACK,CAAC,CAAC,KAAKE,SAAS,EAAE;QAC3B,OAAO,KAAK;MACd;IACF,CAAC,MAAM,IAAIE,KAAK,CAACC,OAAO,CAACF,UAAU,CAAC,EAAE;MACpC,IAAIA,UAAU,CAACG,KAAK,CAAEC,CAAC;QAAA,IAAAC,SAAA;QAAA,OAAKD,CAAC,OAAAC,SAAA,GAAKb,MAAM,CAACK,CAAC,CAAC,cAAAQ,SAAA,uBAATA,SAAA,CAAY,CAAC,CAAC;MAAA,EAAC,EAAE;QACjD,OAAO,KAAK;MACd;IACF,CAAC,MAAM,IAAIL,UAAU,OAAAF,UAAA,GAAKN,MAAM,CAACK,CAAC,CAAC,cAAAC,UAAA,uBAATA,UAAA,CAAY,CAAC,CAAC,GAAE;MACxC,OAAO,KAAK;IACd;EACF;EAEA,OAAO,IAAI;AACb;AAEO,SAASQ,cAAcA,CAC5Bd,MAAc,EACdC,WAAc,EACdc,cAAuB,EACS;EAChC,IAAI,CAAChB,aAAa,CAACC,MAAM,EAAEC,WAAW,CAAC,EAAE;IACvC,IAAI,OAAOc,cAAc,KAAK,QAAQ,EAAE;MACtC,MAAM,IAAIC,KAAK,CAACD,cAAc,CAAC;IACjC;IAEA,MAAMA,cAAc;EACtB;AACF"}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@wyw-in-js/processor-utils",
+  "version": "0.1.0",
+  "dependencies": {
+    "@babel/generator": "^7.23.0",
+    "@wyw-in-js/shared": "0.1.0"
+  },
+  "devDependencies": {
+    "@babel/types": "^7.23.0",
+    "@types/babel__core": "^7.20.2",
+    "@types/babel__generator": "^7.6.5",
+    "@types/node": "^16.18.55",
+    "typescript": "^5.2.2",
+    "@wyw-in-js/babel-config": "0.1.0",
+    "@wyw-in-js/eslint-config": "0.1.0",
+    "@wyw-in-js/ts-config": "0.1.0"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "files": [
+    "types/",
+    "lib/",
+    "esm/"
+  ],
+  "license": "MIT",
+  "main": "lib/index.js",
+  "module": "esm/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "types": "types/index.d.ts",
+  "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:types": "tsc --project ./tsconfig.lib.json --baseUrl . --rootDir ./src",
+    "lint": "eslint --ext .js,.ts .",
+    "test": "jest --config ./jest.config.js --rootDir src"
+  }
+}

package/types/BaseProcessor.d.ts

@@ -0,0 +1,66 @@
+import type { 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 { IFileContext, IOptions } from './utils/types';
+export { Expression };
+export type ProcessorParams = ConstructorParameters<typeof BaseProcessor>;
+export type TailProcessorParams = ProcessorParams extends [Params, ...infer T] ? T : never;
+export type TagSource = {
+    imported: string;
+    source: string;
+};
+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;
+    };
+    readonly location: SourceLocation | null;
+    protected readonly replacer: (replacement: Expression, isPure: boolean) => void;
+    readonly displayName: string;
+    readonly isReferenced: boolean;
+    protected readonly idx: number;
+    protected readonly options: IOptions;
+    protected readonly context: IFileContext;
+    static SKIP: symbol;
+    readonly artifacts: Artifact[];
+    readonly className: string;
+    readonly dependencies: ExpressionValue[];
+    interpolations: IInterpolation[];
+    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, isPure: boolean) => void, displayName: string, isReferenced: boolean, idx: number, options: IOptions, context: IFileContext);
+    /**
+     * A replacement for tag referenced in a template literal.
+     */
+    abstract get asSelector(): string;
+    /**
+     * A replacement for the tag in evaluation time.
+     * For example, `css` tag will be replaced with its className,
+     * whereas `styled` tag will be replaced with an object with metadata.
+     */
+    abstract get value(): Expression;
+    isValidValue(value: unknown): value is Value;
+    toString(): string;
+    protected tagSourceCode(): string;
+    abstract build(values: ValueCache): void;
+    /**
+     * Perform a replacement for the tag in evaluation time.
+     * For example, `css` tag will be replaced with its className,
+     * whereas `styled` tag will be replaced with an object with metadata.
+     */
+    abstract doEvaltimeReplacement(): void;
+    /**
+     * Perform a replacement for the tag with its runtime version.
+     * For example, `css` tag will be replaced with its className,
+     * whereas `styled` tag will be replaced with a component.
+     * If some parts require evaluated data for render,
+     * they will be replaced with placeholders.
+     */
+    abstract doRuntimeReplacement(): void;
+}

package/types/BaseProcessor.js

@@ -0,0 +1,59 @@
+"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 {
+    tagSource;
+    astService;
+    location;
+    replacer;
+    displayName;
+    isReferenced;
+    idx;
+    options;
+    context;
+    static SKIP = Symbol('skip');
+    artifacts = [];
+    className;
+    dependencies = [];
+    interpolations = [];
+    slug;
+    callee;
+    evaluated;
+    constructor(params, tagSource, astService, location, replacer, displayName, isReferenced, idx, options, context) {
+        this.tagSource = tagSource;
+        this.astService = astService;
+        this.location = location;
+        this.replacer = replacer;
+        this.displayName = displayName;
+        this.isReferenced = isReferenced;
+        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);
+        this.className = className;
+        this.slug = slug;
+        [[, this.callee]] = params;
+    }
+    isValidValue(value) {
+        return (typeof value === 'function' || (0, toCSS_1.isCSSable)(value) || (0, shared_1.hasEvalMeta)(value));
+    }
+    toString() {
+        return this.tagSourceCode();
+    }
+    tagSourceCode() {
+        if (this.callee.type === 'Identifier') {
+            return this.callee.name;
+        }
+        return (0, generator_1.default)(this.callee).code;
+    }
+}
+exports.BaseProcessor = BaseProcessor;

package/types/TaggedTemplateProcessor.d.ts

@@ -0,0 +1,20 @@
+import type { Expression, SourceLocation } from '@babel/types';
+import type { TailProcessorParams } from './BaseProcessor';
+import { BaseProcessor } from './BaseProcessor';
+import type { ValueCache, Rules, Params } from './types';
+export declare abstract class TaggedTemplateProcessor extends BaseProcessor {
+    #private;
+    protected constructor(params: Params, ...args: TailProcessorParams);
+    build(values: ValueCache): void;
+    toString(): string;
+    /**
+     * It is called for each resolved expression in a template literal.
+     * @param node
+     * @param precedingCss
+     * @param source
+     * @param unit
+     * @return chunk of CSS that should be added to extracted CSS
+     */
+    abstract addInterpolation(node: Expression, precedingCss: string, source: string, unit?: string): string;
+    abstract extractRules(valueCache: ValueCache, cssText: string, loc?: SourceLocation | null): Rules;
+}

package/types/TaggedTemplateProcessor.js

@@ -0,0 +1,40 @@
+"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 {
+    #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');
+        const [tag, [, template]] = params;
+        super([tag], ...args);
+        template.forEach((element) => {
+            if ('kind' in element && element.kind !== shared_1.ValueType.FUNCTION) {
+                this.dependencies.push(element);
+            }
+        });
+        this.#template = template;
+    }
+    build(values) {
+        if (this.artifacts.length > 0) {
+            // 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);
+        if (artifact) {
+            this.artifacts.push(['css', artifact]);
+        }
+    }
+    toString() {
+        return `${super.toString()}\`…\``;
+    }
+}
+exports.TaggedTemplateProcessor = TaggedTemplateProcessor;

package/types/index.d.ts

@@ -0,0 +1,9 @@
+export { BaseProcessor } from './BaseProcessor';
+export type { Expression, TagSource, ProcessorParams, TailProcessorParams, } from './BaseProcessor';
+export * from './types';
+export { buildSlug } from './utils/buildSlug';
+export type { IOptions, IFileContext } from './utils/types';
+export { isValidParams, validateParams } from './utils/validateParams';
+export type { MapParams, ParamConstraints } from './utils/validateParams';
+export { TaggedTemplateProcessor } from './TaggedTemplateProcessor';
+export { toValidCSSIdentifier } from './utils/toValidCSSIdentifier';

package/types/index.js

@@ -0,0 +1,29 @@
+"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; } });

package/types/types.d.ts

@@ -0,0 +1,32 @@
+import type { Expression, Identifier, TemplateElement, MemberExpression } from '@babel/types';
+import type { ExpressionValue, Location, WYWEvalMeta } from '@wyw-in-js/shared';
+export type CSSPropertyValue = string | number;
+export type ObjectWithSelectors = {
+    [key: string]: ObjectWithSelectors | CSSPropertyValue | (ObjectWithSelectors | CSSPropertyValue)[];
+};
+export type CSSable = ObjectWithSelectors[string];
+export type Value = (() => void) | WYWEvalMeta | CSSable;
+export type ValueCache = Map<string | number | boolean | null, unknown>;
+export interface ICSSRule {
+    atom?: boolean;
+    className: string;
+    cssText: string;
+    displayName: string;
+    start: Location | null | undefined;
+}
+export interface IInterpolation {
+    id: string;
+    node: Expression;
+    source: string;
+    unit: string;
+}
+export type Rules = Record<string, ICSSRule>;
+export type CalleeParam = readonly ['callee', Identifier | MemberExpression];
+export type CallParam = readonly ['call', ...ExpressionValue[]];
+export type MemberParam = readonly ['member', string];
+export type TemplateParam = readonly [
+    'template',
+    (TemplateElement | ExpressionValue)[]
+];
+export type Param = CalleeParam | CallParam | MemberParam | TemplateParam;
+export type Params = readonly Param[];

package/types/types.js

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

package/types/utils/buildSlug.d.ts

@@ -0,0 +1,3 @@
+export declare function buildSlug<TArgs extends Record<string, {
+    toString(): string;
+}>>(pattern: string, args: TArgs): string;

package/types/utils/buildSlug.js

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

package/types/utils/getClassNameAndSlug.d.ts

@@ -0,0 +1,5 @@
+import type { IFileContext, IOptions } from './types';
+export default function getClassNameAndSlug(displayName: string, idx: number, options: IOptions, context: IFileContext): {
+    className: string;
+    slug: string;
+};