@webstudio-is/css-data 0.75.0 → 0.76.0

package/lib/cjs/property-parsers/box-shadow.js

@@ -0,0 +1,128 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var box_shadow_exports = {};
+__export(box_shadow_exports, {
+  parseBoxShadow: () => parseBoxShadow
+});
+module.exports = __toCommonJS(box_shadow_exports);
+var csstree = __toESM(require("css-tree"), 1);
+var import_colord = require("colord");
+const cssTreeTryParseValue = (input) => {
+  try {
+    const ast = csstree.parse(input, { context: "value" });
+    return ast;
+  } catch {
+    return void 0;
+  }
+};
+const parseBoxShadow = (boxShadow) => {
+  let tokenStream = boxShadow.trim();
+  tokenStream = tokenStream.endsWith(";") ? tokenStream.slice(0, -1) : tokenStream;
+  const cleanupKeywords = ["box-shadow:"];
+  for (const cleanupKeyword of cleanupKeywords) {
+    tokenStream = tokenStream.startsWith(cleanupKeyword) ? tokenStream.slice(cleanupKeyword.length).trim() : tokenStream;
+  }
+  const cssAst = cssTreeTryParseValue(tokenStream);
+  if (cssAst === void 0) {
+    return {
+      type: "invalid",
+      value: boxShadow
+    };
+  }
+  const parsed = csstree.lexer.matchProperty("box-shadow", cssAst);
+  if (parsed.error) {
+    return {
+      type: "invalid",
+      value: boxShadow
+    };
+  }
+  const layers = [];
+  csstree.walk(cssAst, (node) => {
+    if (node.type === "Value") {
+      const children = node.children;
+      let layer = [];
+      for (const child of children) {
+        if (children.last === child) {
+          layer.push(child);
+        }
+        if (child.type === "Operator" || children.last === child) {
+          const shadow = [];
+          for (let index = 0; index < layer.length; index++) {
+            const item = layer[index];
+            if (item.type === "Identifier") {
+              shadow.push({
+                type: "keyword",
+                value: item.name
+              });
+            }
+            if (item.type === "Function" || item.type === "Hash") {
+              const colorValue = (0, import_colord.colord)(csstree.generate(item));
+              if (!colorValue.isValid()) {
+                return;
+              }
+              const rgb = colorValue.toRgb();
+              shadow.push({
+                type: "rgb",
+                alpha: rgb.a,
+                r: rgb.r,
+                g: rgb.g,
+                b: rgb.b
+              });
+            }
+            if (item.type === "Dimension") {
+              shadow.push({
+                type: "unit",
+                value: Number(item.value),
+                unit: item.unit
+              });
+            }
+            if (item.type === "Number") {
+              shadow.push({
+                type: "unit",
+                value: Number(item.value),
+                unit: "number"
+              });
+            }
+          }
+          layers.push({
+            type: "tuple",
+            value: shadow
+          });
+          layer = [];
+          continue;
+        }
+        layer.push(child);
+      }
+    }
+  });
+  return layers.length > 0 ? {
+    type: "layers",
+    value: layers
+  } : { type: "invalid", value: boxShadow };
+};

package/lib/cjs/property-parsers/index.js

@@ -16,3 +16,4 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var property_parsers_exports = {};
 module.exports = __toCommonJS(property_parsers_exports);
 __reExport(property_parsers_exports, require("./background"), module.exports);
+__reExport(property_parsers_exports, require("./box-shadow"), module.exports);

package/lib/cjs/property-parsers/parsers.js

@@ -18,7 +18,9 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var parsers_exports = {};
 __export(parsers_exports, {
-  backgroundImage: () => import_background.parseBackgroundImage
+  backgroundImage: () => import_background.parseBackgroundImage,
+  boxShadow: () => import_box_shadow.parseBoxShadow
 });
 module.exports = __toCommonJS(parsers_exports);
 var import_background = require("./background");
+var import_box_shadow = require("./box-shadow");

package/lib/cjs/schema.js

@@ -84,23 +84,28 @@ const UnsetValue = import_zod.z.object({
   type: import_zod.z.literal("unset"),
   value: import_zod.z.literal("")
 });
-const TupleValueItem = import_zod.z.union([UnitValue, KeywordValue, UnparsedValue]);
+const TupleValueItem = import_zod.z.union([
+  UnitValue,
+  KeywordValue,
+  UnparsedValue,
+  RgbValue
+]);
 const TupleValue = import_zod.z.object({
   type: import_zod.z.literal("tuple"),
-  value: import_zod.z.array(TupleValueItem)
+  value: import_zod.z.array(TupleValueItem),
+  hidden: import_zod.z.boolean().optional()
 });
+const LayerValueItem = import_zod.z.union([
+  UnitValue,
+  KeywordValue,
+  UnparsedValue,
+  ImageValue,
+  TupleValue,
+  InvalidValue
+]);
 const LayersValue = import_zod.z.object({
   type: import_zod.z.literal("layers"),
-  value: import_zod.z.array(
-    import_zod.z.union([
-      UnitValue,
-      KeywordValue,
-      UnparsedValue,
-      ImageValue,
-      TupleValue,
-      InvalidValue
-    ])
-  )
+  value: import_zod.z.array(LayerValueItem)
 });
 const ValidStaticStyleValue = import_zod.z.union([
   ImageValue,

package/lib/property-parsers/box-shadow.js

@@ -0,0 +1,98 @@
+import * as csstree from "css-tree";
+import { colord } from "colord";
+const cssTreeTryParseValue = (input) => {
+  try {
+    const ast = csstree.parse(input, { context: "value" });
+    return ast;
+  } catch {
+    return void 0;
+  }
+};
+const parseBoxShadow = (boxShadow) => {
+  let tokenStream = boxShadow.trim();
+  tokenStream = tokenStream.endsWith(";") ? tokenStream.slice(0, -1) : tokenStream;
+  const cleanupKeywords = ["box-shadow:"];
+  for (const cleanupKeyword of cleanupKeywords) {
+    tokenStream = tokenStream.startsWith(cleanupKeyword) ? tokenStream.slice(cleanupKeyword.length).trim() : tokenStream;
+  }
+  const cssAst = cssTreeTryParseValue(tokenStream);
+  if (cssAst === void 0) {
+    return {
+      type: "invalid",
+      value: boxShadow
+    };
+  }
+  const parsed = csstree.lexer.matchProperty("box-shadow", cssAst);
+  if (parsed.error) {
+    return {
+      type: "invalid",
+      value: boxShadow
+    };
+  }
+  const layers = [];
+  csstree.walk(cssAst, (node) => {
+    if (node.type === "Value") {
+      const children = node.children;
+      let layer = [];
+      for (const child of children) {
+        if (children.last === child) {
+          layer.push(child);
+        }
+        if (child.type === "Operator" || children.last === child) {
+          const shadow = [];
+          for (let index = 0; index < layer.length; index++) {
+            const item = layer[index];
+            if (item.type === "Identifier") {
+              shadow.push({
+                type: "keyword",
+                value: item.name
+              });
+            }
+            if (item.type === "Function" || item.type === "Hash") {
+              const colorValue = colord(csstree.generate(item));
+              if (!colorValue.isValid()) {
+                return;
+              }
+              const rgb = colorValue.toRgb();
+              shadow.push({
+                type: "rgb",
+                alpha: rgb.a,
+                r: rgb.r,
+                g: rgb.g,
+                b: rgb.b
+              });
+            }
+            if (item.type === "Dimension") {
+              shadow.push({
+                type: "unit",
+                value: Number(item.value),
+                unit: item.unit
+              });
+            }
+            if (item.type === "Number") {
+              shadow.push({
+                type: "unit",
+                value: Number(item.value),
+                unit: "number"
+              });
+            }
+          }
+          layers.push({
+            type: "tuple",
+            value: shadow
+          });
+          layer = [];
+          continue;
+        }
+        layer.push(child);
+      }
+    }
+  });
+  return layers.length > 0 ? {
+    type: "layers",
+    value: layers
+  } : { type: "invalid", value: boxShadow };
+};
+export {
+  parseBoxShadow
+};

package/lib/property-parsers/index.js

@@ -1 +1,2 @@
 export * from "./background";
+export * from "./box-shadow";

package/lib/property-parsers/parsers.js

@@ -1,4 +1,6 @@
 import { parseBackgroundImage } from "./background";
+import { parseBoxShadow } from "./box-shadow";
 export {
-  parseBackgroundImage as backgroundImage
+  parseBackgroundImage as backgroundImage,
+  parseBoxShadow as boxShadow
 };

package/lib/schema.js

@@ -52,23 +52,28 @@ const UnsetValue = z.object({
   type: z.literal("unset"),
   value: z.literal("")
 });
-const TupleValueItem = z.union([UnitValue, KeywordValue, UnparsedValue]);
+const TupleValueItem = z.union([
+  UnitValue,
+  KeywordValue,
+  UnparsedValue,
+  RgbValue
+]);
 const TupleValue = z.object({
   type: z.literal("tuple"),
-  value: z.array(TupleValueItem)
+  value: z.array(TupleValueItem),
+  hidden: z.boolean().optional()
 });
+const LayerValueItem = z.union([
+  UnitValue,
+  KeywordValue,
+  UnparsedValue,
+  ImageValue,
+  TupleValue,
+  InvalidValue
+]);
 const LayersValue = z.object({
   type: z.literal("layers"),
-  value: z.array(
-    z.union([
-      UnitValue,
-      KeywordValue,
-      UnparsedValue,
-      ImageValue,
-      TupleValue,
-      InvalidValue
-    ])
-  )
+  value: z.array(LayerValueItem)
 });
 const ValidStaticStyleValue = z.union([
   ImageValue,

package/lib/types/__generated__/properties.d.ts

@@ -929,7 +929,7 @@ export declare const properties: {
         readonly inherited: true;
         readonly initial: {
             readonly type: "keyword";
-            readonly value: "inherit";
+            readonly value: "black";
         };
         readonly popularity: 0.90791486;
         readonly appliesTo: "allElementsAndText";
@@ -3105,7 +3105,7 @@ export declare const properties: {
         readonly inherited: true;
         readonly initial: {
             readonly type: "keyword";
-            readonly value: "startOrNamelessValueIfLTRRightIfRTL";
+            readonly value: "start";
         };
         readonly popularity: 0.89287477;
         readonly appliesTo: "blockContainers";