@webstudio-is/sdk 0.275.0 → 0.276.0

package/lib/core-templates.js

@@ -757,7 +757,7 @@ var blockMeta2 = {
       "."
     ] }),
     /* @__PURE__ */ jsxs(ws.element, { "ws:label": "Unordered List", "ws:tag": "ul", children: [
-      /* @__PURE__ */ jsx(ws.element, { "ws:label": "List Item", "ws:tag": "li", children: "In Content mode, you can edit any direct child instances that were pre-added to the Content Block, as well as add new instances predefined in templates." }),
+      /* @__PURE__ */ jsx(ws.element, { "ws:label": "List Item", "ws:tag": "li", children: "In Content mode, you can edit content inside this Content Block and add new instances predefined in templates. Content outside Content Blocks is read-only." }),
       /* @__PURE__ */ jsx(ws.element, { "ws:label": "List Item", "ws:tag": "li", children: "To predefine instances for insertion in Content mode, switch to Design mode and add them to the Templates container." }),
       /* @__PURE__ */ jsx(ws.element, { "ws:label": "List Item", "ws:tag": "li", children: "To insert predefined instances in Content mode, click the + button while hovering over the Content Block on the canvas and choose an instance from the list." })
     ] })

package/lib/index.js

@@ -185,6 +185,7 @@ var projectMeta = z2.object({
   contactEmail: z2.string().optional(),
   faviconAssetId: z2.string().optional(),
   code: z2.string().optional(),
+  agentInstructions: z2.string().optional(),
   auth: z2.string().optional()
 });
 var projectNewRedirectPath = z2.string().min(1, "Path is required").refine((data) => {
@@ -928,7 +929,11 @@ var code = z14.object({
   ...common,
   control: z14.literal("code"),
   type: z14.literal("string"),
-  language: z14.union([z14.literal("html"), z14.literal("markdown")]),
+  language: z14.union([
+    z14.literal("html"),
+    z14.literal("json"),
+    z14.literal("markdown")
+  ]),
   defaultValue: z14.string().optional()
 });
 var codeText = z14.object({
@@ -937,6 +942,12 @@ var codeText = z14.object({
   type: z14.literal("string"),
   defaultValue: z14.string().optional()
 });
+var jsonCode = z14.object({
+  ...common,
+  control: z14.literal("json-code"),
+  type: z14.literal("string"),
+  defaultValue: z14.string().optional()
+});
 var color = z14.object({
   ...common,
   control: z14.literal("color"),
@@ -1052,6 +1063,7 @@ var propMeta = z14.union([
   resource2,
   code,
   codeText,
+  jsonCode,
   color,
   boolean,
   radio,
@@ -1813,6 +1825,289 @@ var summary = [
   { property: "box-sizing", value: { type: "keyword", value: "border-box" } }
 ];
 
+// 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 = (input2) => {
+  try {
+    const value = typeof input2 === "string" ? JSON.parse(input2) : input2;
+    if (isJsonLdValue(value)) {
+      return { success: true, value };
+    }
+  } catch {
+  }
+  return { success: false };
+};
+var validateJsonLd = (input2) => {
+  const parsed = parseJsonLd(input2);
+  if (parsed.success === false) {
+    return {
+      success: false,
+      diagnostics: [
+        {
+          severity: "error",
+          code: typeof input2 === "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";
 
@@ -2924,8 +3219,10 @@ var generateResources = ({
   resources: resources2
 }) => {
   const usedDataSources = /* @__PURE__ */ new Map();
+  const generatedResourceIds = /* @__PURE__ */ new Set();
   let generatedRequests = "";
   for (const resource3 of resources2.values()) {
+    generatedResourceIds.add(resource3.id);
     let generatedRequest = "";
     const resourceName = scope.getName(resource3.id, resource3.name);
     generatedRequest += `  const ${resourceName}: ResourceRequest = {
@@ -3014,7 +3311,7 @@ var generateResources = ({
   generated += `  const _data = new Map<string, ResourceRequest>([
 `;
   for (const dataSource2 of dataSources2.values()) {
-    if (dataSource2.type === "resource") {
+    if (dataSource2.type === "resource" && generatedResourceIds.has(dataSource2.resourceId)) {
       const name = scope.getName(dataSource2.resourceId, dataSource2.name);
       generated += `    ["${name}", ${name}],
 `;
@@ -3025,7 +3322,7 @@ var generateResources = ({
   generated += `  const _action = new Map<string, ResourceRequest>([
 `;
   for (const prop2 of props2.values()) {
-    if (prop2.type === "resource") {
+    if (prop2.type === "resource" && generatedResourceIds.has(prop2.value)) {
       const name = scope.getName(prop2.value, prop2.name);
       generated += `    ["${name}", ${name}],
 `;
@@ -3675,6 +3972,7 @@ export {
   elementComponent,
   encodeDataVariableId as encodeDataSourceVariable,
   encodeDataVariableId,
+  escapeJsonLdScriptText,
   executeExpression,
   expressionChild,
   fileAsset,
@@ -3711,6 +4009,7 @@ export {
   getPagePath,
   getStaticSiteMapXml,
   getStyleDeclKey,
+  hasTopLevelJsonLdContext,
   homePagePath,
   idChild,
   imageAsset,
@@ -3751,6 +4050,7 @@ export {
   pageTitle,
   pages,
   parseComponentName,
+  parseJsonLd,
   parseObjectExpression,
   portalComponent,
   presetStyleDecl,
@@ -3784,6 +4084,7 @@ export {
   toRuntimeAsset,
   transpileExpression,
   validateFileName,
+  validateJsonLd,
   viewAnimation,
   webstudioFragment,
   wsComponentMeta