@webstudio-is/sdk 0.274.5 → 0.276.0

package/lib/runtime.js

@@ -149,10 +149,294 @@ var isBraveBrowser = () => {
   return navigator.brave?.isBrave?.() === true || navigator.brave !== void 0;
 };
 
+// src/json-ld-utils.ts
+var isJsonObject = (value) => typeof value === "object" && value !== null && Array.isArray(value) === false;
+var appendJsonPath = (path, key) => typeof key === "number" ? `${path}[${key}]` : /^[A-Za-z_$][\w$]*$/.test(key) ? `${path}.${key}` : `${path}[${JSON.stringify(key)}]`;
+var getJsonLdTypes = (value) => typeof value === "string" ? [value] : Array.isArray(value) && value.every((item) => typeof item === "string") ? value : [];
+
+// src/json-ld.ts
+var pushKeywordTypeError = (diagnostics, path, message) => {
+  diagnostics.push({
+    severity: "error",
+    code: "invalid-keyword-value",
+    path,
+    message
+  });
+};
+var escapeJsonLdScriptText = (value) => value.replace(/</g, "\\u003c");
+var validateContextTermDefinition = (definition, path, diagnostics) => {
+  if (definition === null || typeof definition === "string" || isJsonObject(definition)) {
+    if (isJsonObject(definition) && definition["@context"] !== void 0) {
+      validateContext(
+        definition["@context"],
+        appendJsonPath(path, "@context"),
+        diagnostics
+      );
+    }
+    return;
+  }
+  diagnostics.push({
+    severity: "error",
+    code: "invalid-context",
+    path,
+    message: "JSON-LD context terms must map to a string, object, or null."
+  });
+};
+var validateContext = (context, path, diagnostics) => {
+  if (context === null || typeof context === "string") {
+    return;
+  }
+  if (Array.isArray(context)) {
+    context.forEach(
+      (item, index) => validateContext(item, appendJsonPath(path, index), diagnostics)
+    );
+    return;
+  }
+  if (isJsonObject(context) === false) {
+    diagnostics.push({
+      severity: "error",
+      code: "invalid-context",
+      path,
+      message: "@context must be a string, object, array of contexts, or null."
+    });
+    return;
+  }
+  for (const keyword of ["@base", "@vocab", "@language"]) {
+    if (context[keyword] !== void 0 && context[keyword] !== null && typeof context[keyword] !== "string") {
+      diagnostics.push({
+        severity: "error",
+        code: "invalid-context",
+        path: appendJsonPath(path, keyword),
+        message: `${keyword} must be a string or null.`
+      });
+    }
+  }
+  if (context["@direction"] !== void 0 && context["@direction"] !== null && context["@direction"] !== "ltr" && context["@direction"] !== "rtl") {
+    diagnostics.push({
+      severity: "error",
+      code: "invalid-context",
+      path: appendJsonPath(path, "@direction"),
+      message: '@direction must be "ltr", "rtl", or null.'
+    });
+  }
+  if (context["@propagate"] !== void 0 && typeof context["@propagate"] !== "boolean") {
+    diagnostics.push({
+      severity: "error",
+      code: "invalid-context",
+      path: appendJsonPath(path, "@propagate"),
+      message: "@propagate must be a boolean."
+    });
+  }
+  if (context["@version"] !== void 0 && context["@version"] !== 1.1) {
+    diagnostics.push({
+      severity: "error",
+      code: "invalid-context",
+      path: appendJsonPath(path, "@version"),
+      message: "@version must be 1.1."
+    });
+  }
+  for (const [term, definition] of Object.entries(context)) {
+    if (term.startsWith("@")) {
+      continue;
+    }
+    validateContextTermDefinition(
+      definition,
+      appendJsonPath(path, term),
+      diagnostics
+    );
+  }
+};
+var validateNestedValues = (value, path, diagnostics) => {
+  if (isJsonObject(value)) {
+    validateNode(value, path, diagnostics);
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => {
+      if (isJsonObject(item) || Array.isArray(item)) {
+        validateNestedValues(item, appendJsonPath(path, index), diagnostics);
+      }
+    });
+  }
+};
+var validateNode = (value, path, diagnostics) => {
+  if (Array.isArray(value)) {
+    value.forEach(
+      (item, index) => validateNode(item, appendJsonPath(path, index), diagnostics)
+    );
+    return;
+  }
+  if (isJsonObject(value) === false) {
+    diagnostics.push({
+      severity: "error",
+      code: "invalid-root",
+      path,
+      message: "JSON-LD nodes must be objects."
+    });
+    return;
+  }
+  if (value["@context"] !== void 0) {
+    validateContext(
+      value["@context"],
+      appendJsonPath(path, "@context"),
+      diagnostics
+    );
+  }
+  const typeValue = value["@type"];
+  if (typeValue !== void 0 && (getJsonLdTypes(typeValue).length === 0 || Array.isArray(typeValue) && typeValue.length === 0)) {
+    pushKeywordTypeError(
+      diagnostics,
+      appendJsonPath(path, "@type"),
+      "@type must be a non-empty string or array of strings."
+    );
+  }
+  if (value["@id"] !== void 0 && typeof value["@id"] !== "string") {
+    pushKeywordTypeError(
+      diagnostics,
+      appendJsonPath(path, "@id"),
+      "@id must be a string."
+    );
+  }
+  if (value["@graph"] !== void 0 && isJsonObject(value["@graph"]) === false && Array.isArray(value["@graph"]) === false) {
+    pushKeywordTypeError(
+      diagnostics,
+      appendJsonPath(path, "@graph"),
+      "@graph must be an object or array of objects."
+    );
+  }
+  if (value["@language"] !== void 0 && value["@language"] !== null && typeof value["@language"] !== "string") {
+    pushKeywordTypeError(
+      diagnostics,
+      appendJsonPath(path, "@language"),
+      "@language must be a string or null."
+    );
+  }
+  if (value["@nest"] !== void 0 && isJsonObject(value["@nest"]) === false && (Array.isArray(value["@nest"]) === false || value["@nest"].every(isJsonObject) === false)) {
+    pushKeywordTypeError(
+      diagnostics,
+      appendJsonPath(path, "@nest"),
+      "@nest must be an object or array of objects."
+    );
+  }
+  if (value["@reverse"] !== void 0 && isJsonObject(value["@reverse"]) === false) {
+    pushKeywordTypeError(
+      diagnostics,
+      appendJsonPath(path, "@reverse"),
+      "@reverse must be an object."
+    );
+  }
+  for (const keyword of ["@index"]) {
+    if (value[keyword] !== void 0 && typeof value[keyword] !== "string") {
+      pushKeywordTypeError(
+        diagnostics,
+        appendJsonPath(path, keyword),
+        `${keyword} must be a string.`
+      );
+    }
+  }
+  if (value["@direction"] !== void 0 && value["@direction"] !== "ltr" && value["@direction"] !== "rtl" && value["@direction"] !== null) {
+    pushKeywordTypeError(
+      diagnostics,
+      appendJsonPath(path, "@direction"),
+      '@direction must be "ltr", "rtl", or null.'
+    );
+  }
+  if ("@value" in value) {
+    const invalidKeys = ["@id", "@graph", "@list", "@set", "@reverse"].filter(
+      (key) => key in value
+    );
+    const isJsonLiteral = value["@type"] === "@json";
+    const hasStructuredValue = typeof value["@value"] === "object" && value["@value"] !== null;
+    if (invalidKeys.length > 0 || hasStructuredValue && isJsonLiteral === false || "@type" in value && value["@type"] !== "@json" && ("@language" in value || "@direction" in value)) {
+      diagnostics.push({
+        severity: "error",
+        code: "invalid-value-object",
+        path,
+        message: "A JSON-LD value object has an incompatible keyword or @value shape."
+      });
+    }
+  }
+  for (const [property, propertyValue] of Object.entries(value)) {
+    const propertyPath = appendJsonPath(path, property);
+    if (property === "@context") {
+      continue;
+    }
+    if (["@graph", "@included", "@nest", "@reverse"].includes(property)) {
+      validateNode(propertyValue, propertyPath, diagnostics);
+      continue;
+    }
+    if (property.startsWith("@")) {
+      if (["@list", "@set"].includes(property)) {
+        validateNestedValues(propertyValue, propertyPath, diagnostics);
+      }
+      continue;
+    }
+    validateNestedValues(propertyValue, propertyPath, diagnostics);
+  }
+};
+var isJsonLdData = (value, ancestors) => {
+  if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value)) {
+    return true;
+  }
+  if (typeof value !== "object" || value === null || ancestors.has(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (Array.isArray(value) === false && prototype !== Object.prototype) {
+    return false;
+  }
+  ancestors.add(value);
+  const isValid = Array.isArray(value) ? value.every((item) => isJsonLdData(item, ancestors)) : Object.values(value).every((item) => isJsonLdData(item, ancestors));
+  ancestors.delete(value);
+  return isValid;
+};
+var isJsonLdValue = (value) => (Array.isArray(value) || isJsonObject(value)) && isJsonLdData(value, /* @__PURE__ */ new Set());
+var parseJsonLd = (input) => {
+  try {
+    const value = typeof input === "string" ? JSON.parse(input) : input;
+    if (isJsonLdValue(value)) {
+      return { success: true, value };
+    }
+  } catch {
+  }
+  return { success: false };
+};
+var validateJsonLd = (input) => {
+  const parsed = parseJsonLd(input);
+  if (parsed.success === false) {
+    return {
+      success: false,
+      diagnostics: [
+        {
+          severity: "error",
+          code: typeof input === "string" ? "invalid-json" : "invalid-root",
+          path: "$",
+          message: "JSON-LD must be a valid JSON object or array."
+        }
+      ]
+    };
+  }
+  const diagnostics = [];
+  validateNode(parsed.value, "$", diagnostics);
+  if (diagnostics.length > 0) {
+    return { success: false, value: parsed.value, diagnostics };
+  }
+  return { success: true, value: parsed.value, diagnostics };
+};
+var hasTopLevelJsonLdContext = (value) => {
+  if (Array.isArray(value)) {
+    return value.some(
+      (item) => typeof item === "object" && item !== null && "@context" in item
+    );
+  }
+  return "@context" in value;
+};
+
 // src/runtime.ts
 var tagProperty = "data-ws-tag";
 var getTagFromProps = (props) => {
-  return props[tagProperty];
+  const tag = props[tagProperty];
+  return typeof tag === "string" && tag.length > 0 ? tag : void 0;
 };
 var indexProperty = "data-ws-index";
 var getIndexWithinAncestorFromProps = (props) => {
@@ -165,17 +449,21 @@ export {
   cachedFetch,
   createJsonStringifyProxy,
   currentDateResourceUrl,
+  escapeJsonLdScriptText,
   formBotFieldName,
   formIdFieldName,
   getIndexWithinAncestorFromProps,
   getTagFromProps,
+  hasTopLevelJsonLdContext,
   indexProperty,
   isBraveBrowser,
   isLocalResource,
   isPlainObject,
   loadResource,
   loadResources,
+  parseJsonLd,
   serializeValue,
   sitemapResourceUrl,
-  tagProperty
+  tagProperty,
+  validateJsonLd
 };