@adobe/spectrum-tokens 13.0.0-beta.2 → 13.0.0-beta.21

package/test/checkId.test.js

@@ -20,45 +20,67 @@ const files = await Promise.all(
   ),
 );
 
-const uuids = [];
-const missingUUIDs = [];
-const VALUE = "value";
-const UUID = "uuid";
+// const uuids = [];
+// const missingUUIDs = [];
+// const VALUE = "value";
+// const UUID = "uuid";
 
-function isObject(a) {
-  return (
-    !!a &&
-    a.constructor &&
-    (a.constructor === Object || a.constructor.name === "Object")
-  );
-}
+// function isObject(a) {
+//   return (
+//     !!a &&
+//     a.constructor &&
+//     (a.constructor === Object || a.constructor.name === "Object")
+//   );
+// }
 
-// check for and add uuids
-function checkUUID(json, name) {
-  // if it is in want of uuid, give it one
-  if (json[VALUE] && !json[UUID]) {
-    if (!json[UUID] || uuids.includes(json[UUID])) {
-      if (name) {
-        missingUUIDs.push(name);
-      } else {
-        missingUUIDs.push(json[VALUE]);
-      }
-    }
+// // check for uuids
+// function checkUUID(json, name) {
+//   if (json[VALUE] && !json[UUID]) {
+//     if (!json[UUID]) {
+//       if (name) {
+//         missingUUIDs.push(name);
+//       } else {
+//         missingUUIDs.push(json[VALUE]);
+//       }
+//     }
+//     else if (uuids.includes(json[UUID])) {
 
-    uuids.push(json[UUID]);
-  }
+//     }
+//     uuids.push(json[UUID]);
+//   }
 
-  // handle the json's children
-  Object.keys(json).forEach((key) => {
-    if (isObject(json[key])) {
-      checkUUID(json[key], key);
+//   // handle the json's children
+//   Object.keys(json).forEach((key) => {
+//     if (isObject(json[key])) {
+//       checkUUID(json[key], key);
+//     }
+//   });
+// }
+const findDuplicateUUIDs = (json) => {
+  const uuids = [];
+  const duplicateUUIDs = [];
+  const gather = (json, name) => {
+    if (json.uuid) {
+      if (uuids.includes(json.uuid)) {
+        duplicateUUIDs.push({ uuid: json.uuid, name });
+      }
+      uuids.push(json.uuid);
     }
-  });
-}
+    Object.keys(json).forEach((key) => {
+      if (typeof json[key] === "object") {
+        gather(json[key], key);
+      }
+    });
+  };
+  gather(json);
+  return duplicateUUIDs;
+};
 
-test("check for uuids", async (t) => {
+test("ensure uuids are unique", async (t) => {
+  let allTokens = {};
   for (const file of files) {
-    checkUUID(file);
+    allTokens = { ...allTokens, ...file };
   }
-  t.deepEqual(missingUUIDs, []);
+  const duplicateUUIDs = findDuplicateUUIDs(allTokens);
+  t.deepEqual(duplicateUUIDs, [], "duplicate uuids found");
 });

package/test/componentSchemaValidator.test.js

@@ -0,0 +1,74 @@
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+import test from "ava";
+import Ajv from "ajv/dist/2020.js";
+import addFormats from "ajv-formats";
+import { glob } from "glob";
+import { readFile } from "fs/promises";
+
+const readJSON = async (filePath) =>
+  JSON.parse(await readFile(filePath, "utf8"));
+const componentSchema = await readJSON("schemas/component.json");
+
+const fileNames = await glob("schemas/components/*.json");
+const files = await Promise.all(
+  fileNames.map(async (fileName) => {
+    return { fileName, json: await readJSON(fileName) };
+  }),
+);
+
+const ajv = new Ajv();
+addFormats(ajv);
+ajv.addMetaSchema(componentSchema);
+const schemaFiles = await glob("schemas/types/*.json");
+for (const schemaFile of schemaFiles) {
+  const schema = await readJSON(schemaFile);
+  ajv.addSchema(schema);
+}
+
+for (const keyword of Object.keys(componentSchema.properties)) {
+  ajv.addKeyword({ keyword, metaSchema: componentSchema.properties[keyword] });
+}
+
+test("component schema should be valid", async (t) => {
+  const valid = ajv.validateSchema(componentSchema);
+  t.true(valid);
+});
+
+test("Every component schema should validate against the definition", (t) => {
+  let valid = true;
+  for (const file of files) {
+    if (!ajv.validateSchema(file.json)) {
+      valid = false;
+      console.log(`${file.fileName} failed validation`);
+      console.log(ajv.errors);
+    }
+  }
+  t.true(valid);
+});
+
+test("component examples should validate against the definition", (t) => {
+  let valid = true;
+  for (const file of files) {
+    const validate = ajv.compile(file.json);
+    if (!Object.hasOwn(file.json, "examples")) file.json.examples = [];
+    for (const example of file.json.examples) {
+      if (!validate(example)) {
+        valid = false;
+        console.log(`${file.fileName} failed validation`);
+        console.log(validate.errors);
+      }
+    }
+  }
+  t.true(valid);
+});

package/test/schemaValidators/alias.test.js

@@ -0,0 +1,41 @@
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+import test from "ava";
+import Ajv from "ajv/dist/2020.js";
+import addFormats from "ajv-formats";
+import { readFile } from "fs/promises";
+
+const readJSON = async (filePath) =>
+  JSON.parse(await readFile(filePath, "utf8"));
+
+const ajv = new Ajv();
+addFormats(ajv);
+
+ajv.addSchema(await readJSON("schemas/token-types/token.json"));
+const validate = await ajv.compile(
+  await readJSON("schemas/token-types/alias.json"),
+);
+
+test("Every token schema should validate against the definition", (t) => {
+  const alias = {
+    component: "swatch",
+    $schema:
+      "https://opensource.adobe.com/spectrum-tokens/schemas/token-types/alias.json",
+    value: "{gray-900}",
+    uuid: "7da5157d-7f25-405b-8de0-f3669565fb48",
+  };
+  if (!validate(alias)) {
+    console.log(validate.errors);
+  }
+  t.pass();
+});

package/test/tokenSchemaValidator.test.js

@@ -0,0 +1,97 @@
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+import test from "ava";
+import Ajv from "ajv/dist/2020.js";
+import addFormats from "ajv-formats";
+import { glob } from "glob";
+import { readFile } from "fs/promises";
+
+const readJSON = async (filePath) =>
+  JSON.parse(await readFile(filePath, "utf8"));
+
+const ajv = new Ajv();
+addFormats(ajv);
+
+test.before(async (t) => {
+  const schemaFileNames = await glob("schemas/token-types/*.json");
+  const schemaIds = await Promise.all(
+    schemaFileNames.map(async (fileName) => {
+      const json = await readJSON(fileName);
+      try {
+        ajv.addSchema(json, json["$id"]);
+      } catch (error) {
+        console.log(error);
+        console.log(`${fileName} error with $id ${json["$id"]}`);
+      }
+      return json["$id"];
+    }),
+  );
+  t.context.schemaIds = schemaIds;
+
+  const tokenFilesNames = await glob("src/*.json");
+  t.context.tokenFiles = await Promise.all(
+    tokenFilesNames.map(async (tokenFile) => {
+      return { fileName: tokenFile, data: await readJSON(tokenFile) };
+    }),
+  );
+});
+
+test("Schema should compile without errors", async (t) => {
+  try {
+    const validate = await ajv.compile({
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      type: "object",
+      patternProperties: {
+        "^(?:(?:[a-z]|\\d)+-?)*(?:[a-z]|\\d)+$": {
+          anyOf: t.context.schemaIds.map((schemaId) => ({ $ref: schemaId })),
+        },
+      },
+    });
+  } catch (error) {
+    console.log(error);
+  }
+  t.pass();
+});
+
+test("Every token should have a $schema property", (t) => {
+  t.context.tokenFiles.forEach((tokenFileObj) => {
+    Object.keys(tokenFileObj.data).forEach((tokenName) => {
+      t.true(
+        Object.hasOwn(tokenFileObj.data[tokenName], "$schema"),
+        `${tokenName} in ${tokenFileObj.fileName} does not have a $schema property.`,
+      );
+    });
+  });
+});
+
+test("Every token schema should validate against the definition", (t) => {
+  const errors = [];
+  t.context.tokenFiles.forEach((tokenFileObj) => {
+    Object.keys(tokenFileObj.data).forEach((tokenName) => {
+      if (
+        !ajv.validate(
+          tokenFileObj.data[tokenName]["$schema"],
+          tokenFileObj.data[tokenName],
+        )
+      ) {
+        t.log(`${tokenName} in ${tokenFileObj.fileName} failed validation.`);
+        errors.push({
+          tokenName,
+          fileName: tokenFileObj.fileName,
+          errors: ajv.errors,
+        });
+      }
+    });
+  });
+  t.deepEqual(errors, []);
+});