@webstudio-is/sdk 0.267.0 → 0.269.0

package/lib/index.js

@@ -44,6 +44,7 @@ var Assets = z.map(AssetId, Asset);
 
 // src/schema/pages.ts
 import { z as z2 } from "zod";
+import { validateBasicAuth } from "@webstudio-is/wsauth";
 var MIN_TITLE_LENGTH = 2;
 var PageId = z2.string();
 var FolderId = z2.string();
@@ -63,7 +64,36 @@ var PageTitle = z2.string().refine(
   (val) => val.length >= MIN_TITLE_LENGTH,
   `Minimum ${MIN_TITLE_LENGTH} characters required`
 );
-var documentTypes = ["html", "xml"];
+var documentTypes = ["html", "xml", "text"];
+var BasicAuthFields = {
+  login: z2.string(),
+  password: z2.string()
+};
+var validateBasicAuthFields = ({
+  login,
+  password
+}, context) => {
+  for (const issue of validateBasicAuth({ login, password }).issues ?? []) {
+    context.addIssue({
+      code: z2.ZodIssueCode.custom,
+      path: issue.path,
+      message: issue.message
+    });
+  }
+};
+var PageBasicAuth = z2.object({
+  method: z2.literal("basic"),
+  ...BasicAuthFields
+}).superRefine(validateBasicAuthFields);
+var LegacyPageBasicAuth = z2.object({
+  type: z2.literal("basic"),
+  ...BasicAuthFields
+}).superRefine(validateBasicAuthFields).transform(({ login, password }) => ({
+  method: "basic",
+  login,
+  password
+}));
+var PageAuth = z2.union([PageBasicAuth, LegacyPageBasicAuth]);
 var commonPageFields = {
   id: PageId,
   name: PageName,
@@ -81,6 +111,8 @@ var commonPageFields = {
     status: z2.string().optional(),
     redirect: z2.string().optional(),
     documentType: z2.optional(z2.enum(documentTypes)),
+    content: z2.string().optional(),
+    auth: PageAuth.optional(),
     custom: z2.array(
       z2.object({
         property: z2.string(),
@@ -131,12 +163,21 @@ var Page = z2.object({
   ...commonPageFields,
   path: z2.union([HomePagePath, PagePath])
 });
+var PageTemplate = z2.object({
+  id: PageId,
+  name: PageName,
+  title: PageTitle,
+  rootInstanceId: z2.string(),
+  systemDataSourceId: z2.string().optional(),
+  meta: commonPageFields.meta
+});
 var ProjectMeta = z2.object({
   // All fields are optional to ensure consistency and allow for the addition of new fields without requiring migration
   siteName: z2.string().optional(),
   contactEmail: z2.string().optional(),
   faviconAssetId: z2.string().optional(),
-  code: z2.string().optional()
+  code: z2.string().optional(),
+  auth: z2.string().optional()
 });
 var ProjectNewRedirectPath = z2.string().min(1, "Path is required").refine((data) => {
   try {
@@ -162,6 +203,7 @@ var Pages = z2.object({
   homePageId: PageId,
   rootFolderId: FolderId,
   pages: z2.map(PageId, Page),
+  pageTemplates: z2.map(PageId, PageTemplate).optional(),
   folders: z2.map(FolderId, Folder).refine((folders) => folders.size > 0, "Folders can't be empty")
 }).superRefine((pages, context) => {
   const homePage = pages.pages.get(pages.homePageId);
@@ -203,6 +245,22 @@ var Pages = z2.object({
       });
     }
   }
+  for (const [templateId, template] of pages.pageTemplates ?? []) {
+    if (template.id !== templateId) {
+      context.addIssue({
+        code: z2.ZodIssueCode.custom,
+        path: ["pageTemplates", templateId, "id"],
+        message: "Page template id must match its record key"
+      });
+    }
+    if (pages.pages.has(templateId)) {
+      context.addIssue({
+        code: z2.ZodIssueCode.custom,
+        path: ["pageTemplates", templateId, "id"],
+        message: "Page template id must not match an existing page id"
+      });
+    }
+  }
   for (const [folderId, folder] of pages.folders) {
     if (folder.id !== folderId) {
       context.addIssue({
@@ -895,6 +953,13 @@ var Select = z14.object({
   defaultValue: z14.string().optional(),
   options: z14.array(z14.string())
 });
+var TimeZone = z14.object({
+  ...common,
+  control: z14.literal("timeZone"),
+  type: z14.literal("string"),
+  defaultValue: z14.string().optional(),
+  options: z14.array(z14.string())
+});
 var Check = z14.object({
   ...common,
   control: z14.literal("check"),
@@ -975,6 +1040,7 @@ var PropMeta = z14.union([
   Radio,
   InlineRadio,
   Select,
+  TimeZone,
   MultiSelect,
   Check,
   InlineCheck,
@@ -1006,6 +1072,7 @@ var componentCategories = [
   "localization",
   "radix",
   "xml",
+  "text",
   "other",
   "hidden",
   "internal"
@@ -2052,6 +2119,29 @@ var parseComponentName = (componentName) => {
   }
   return [namespace, name];
 };
+var getHtmlTagsFromProps = (props) => {
+  const tags2 = /* @__PURE__ */ new Map();
+  for (const prop of props.values()) {
+    if (prop.type === "string" && prop.name === "tag") {
+      tags2.set(prop.instanceId, prop.value);
+    }
+  }
+  return tags2;
+};
+var getHtmlTagFromInstance = ({
+  instance,
+  metas,
+  props,
+  htmlTagsByInstanceId
+}) => {
+  if (instance.component === "XmlNode") {
+    return;
+  }
+  const meta = metas.get(instance.component);
+  const metaTag = Object.keys(meta?.presetStyle ?? {}).at(0);
+  const propTag = htmlTagsByInstanceId?.get(instance.id) ?? getHtmlTagsFromProps(props).get(instance.id);
+  return instance.tag ?? propTag ?? metaTag;
+};
 var getIndexesWithinAncestors = (metas, instances, rootIds) => {
   const ancestors = /* @__PURE__ */ new Set();
   for (const meta of metas.values()) {
@@ -2111,24 +2201,175 @@ var systemParameter = {
   type: "parameter",
   name: "system"
 };
-var allowedStringMethods = /* @__PURE__ */ new Set([
-  "toLowerCase",
-  "replace",
-  "split",
-  "slice",
-  "at",
-  "endsWith",
-  "includes",
-  "startsWith",
-  "toUpperCase",
-  "toLocaleLowerCase",
-  "toLocaleUpperCase"
+var walkAssignmentTarget = (node, visitor) => {
+  if (node.type === "Identifier") {
+    visitor.Identifier?.(node, "binding");
+    return;
+  }
+  if (node.type === "MemberExpression") {
+    visitor.MemberExpression?.(node);
+    const { object } = node;
+    if (object.type === "Identifier") {
+      visitor.Identifier?.(object, "memberObject");
+    } else if (object.type === "MemberExpression") {
+      walkAssignmentTarget(object, visitor);
+    }
+    return;
+  }
+  visitor.UnsupportedPattern?.(node);
+};
+var stringMethodReturnKindByName = /* @__PURE__ */ new Map([
+  ["toLowerCase", "string"],
+  ["replace", "string"],
+  ["split", "array"],
+  ["slice", "string"],
+  ["at", "unknown"],
+  ["endsWith", "boolean"],
+  ["includes", "boolean"],
+  ["startsWith", "boolean"],
+  ["toString", "string"],
+  ["toUpperCase", "string"],
+  ["toLocaleLowerCase", "string"],
+  ["toLocaleUpperCase", "string"]
+]);
+var arrayMethodReturnKindByName = /* @__PURE__ */ new Map([
+  ["at", "unknown"],
+  ["includes", "boolean"],
+  ["join", "string"],
+  ["slice", "array"],
+  ["toString", "string"]
 ]);
-var allowedArrayMethods = /* @__PURE__ */ new Set(["at", "includes", "join", "slice"]);
+var allowedStringMethods = new Set(
+  stringMethodReturnKindByName.keys()
+);
+var allowedArrayMethods = new Set(arrayMethodReturnKindByName.keys());
+var getVariableValue = (variableValues, name) => {
+  if (variableValues === void 0) {
+    return;
+  }
+  const maybeMap = variableValues;
+  if (typeof maybeMap.has === "function" && typeof maybeMap.get === "function") {
+    if (maybeMap.has(name)) {
+      return { value: maybeMap.get(name) };
+    }
+    return;
+  }
+  const record = variableValues;
+  if (Object.hasOwn(record, name)) {
+    return { value: record[name] };
+  }
+};
+var getValueKind = (value) => {
+  if (Array.isArray(value)) {
+    return "array";
+  }
+  if (value === void 0 || value === null) {
+    return "nullish";
+  }
+  switch (typeof value) {
+    case "bigint":
+      return "bigint";
+    case "boolean":
+      return "boolean";
+    case "number":
+      return "number";
+    case "string":
+      return "string";
+    case "object":
+      return "object";
+    default:
+      return "unknown";
+  }
+};
+var getMethodReturnKind = (receiverKind, methodName) => {
+  if (receiverKind === "array") {
+    return arrayMethodReturnKindByName.get(methodName) ?? "unknown";
+  }
+  if (receiverKind === "string") {
+    return stringMethodReturnKindByName.get(methodName) ?? "unknown";
+  }
+  if (receiverKind === "unknown") {
+    const stringReturnKind = stringMethodReturnKindByName.get(methodName);
+    const arrayReturnKind = arrayMethodReturnKindByName.get(methodName);
+    if (stringReturnKind && arrayReturnKind === void 0) {
+      return stringReturnKind;
+    }
+    if (arrayReturnKind && stringReturnKind === void 0) {
+      return arrayReturnKind;
+    }
+    if (stringReturnKind === arrayReturnKind) {
+      return stringReturnKind ?? "unknown";
+    }
+    return "unknown";
+  }
+  return methodName === "toString" ? "string" : "unknown";
+};
+var isMethodSupported = (receiverKind, methodName) => {
+  if (receiverKind === "unknown") {
+    return allowedStringMethods.has(methodName) || allowedArrayMethods.has(methodName);
+  }
+  if (receiverKind === "string") {
+    return stringMethodReturnKindByName.has(methodName);
+  }
+  if (receiverKind === "array") {
+    return arrayMethodReturnKindByName.has(methodName);
+  }
+  if (receiverKind === "nullish") {
+    return false;
+  }
+  return methodName === "toString";
+};
+var getExpressionNodeValueKind = (node, variableValues) => {
+  if (node.type === "Identifier") {
+    if (node.name === "undefined") {
+      return "nullish";
+    }
+    const variable = getVariableValue(variableValues, node.name);
+    return variable ? getValueKind(variable.value) : "unknown";
+  }
+  if (node.type === "Literal") {
+    return getValueKind(node.value);
+  }
+  if (node.type === "ArrayExpression") {
+    return "array";
+  }
+  if (node.type === "ObjectExpression") {
+    return "object";
+  }
+  if (node.type === "TemplateLiteral") {
+    return "string";
+  }
+  if (node.type === "ChainExpression" || node.type === "ParenthesizedExpression") {
+    return getExpressionNodeValueKind(node.expression, variableValues);
+  }
+  if (node.type === "CallExpression" && node.callee.type === "MemberExpression" && node.callee.object.type !== "Super" && node.callee.property.type === "Identifier") {
+    const receiverKind = getExpressionNodeValueKind(
+      node.callee.object,
+      variableValues
+    );
+    const methodName = node.callee.property.name;
+    if (isMethodSupported(receiverKind, methodName)) {
+      return getMethodReturnKind(receiverKind, methodName);
+    }
+  }
+  return "unknown";
+};
+var getExpressionValueKind = ({
+  expression,
+  variableValues
+}) => {
+  try {
+    const node = parseExpressionAt(expression, 0, { ecmaVersion: "latest" });
+    return getExpressionNodeValueKind(node, variableValues);
+  } catch {
+    return "unknown";
+  }
+};
 var lintExpression = ({
   expression,
   availableVariables = /* @__PURE__ */ new Set(),
-  allowAssignment = false
+  allowAssignment = false,
+  variableValues
 }) => {
   const diagnostics = [];
   const addMessage = (message, severity = "error") => {
@@ -2193,15 +2434,21 @@ var lintExpression = ({
           addMessage("Assignment is supported only inside actions")(node);
           return;
         }
-        simple(node.left, {
-          Identifier(node2) {
+        walkAssignmentTarget(node.left, {
+          Identifier(node2, kind) {
+            if (kind !== "binding") {
+              return;
+            }
             if (availableVariables.has(node2.name) === false) {
               addMessage(
                 `"${node2.name}" is not defined in the scope`,
                 "warning"
               )(node2);
             }
-          }
+          },
+          UnsupportedPattern: addMessage(
+            "Destructuring assignment is not supported"
+          )
         });
       },
       // parser forbids to yield inside module
@@ -2215,7 +2462,11 @@ var lintExpression = ({
         if (node.callee.type === "MemberExpression") {
           if (node.callee.property.type === "Identifier") {
             const methodName = node.callee.property.name;
-            if (allowedStringMethods.has(methodName) || allowedArrayMethods.has(methodName)) {
+            const receiverKind = node.callee.object.type === "Super" ? "unknown" : getExpressionNodeValueKind(
+              node.callee.object,
+              variableValues
+            );
+            if (isMethodSupported(receiverKind, methodName)) {
               return;
             }
             calleeName = methodName;
@@ -2295,7 +2546,7 @@ var getExpressionIdentifiers = (expression) => {
     simple(root, {
       Identifier: (node) => identifiers2.add(node.name),
       AssignmentExpression(node) {
-        simple(node.left, {
+        walkAssignmentTarget(node.left, {
           Identifier: (node2) => identifiers2.add(node2.name)
         });
       }
@@ -2316,17 +2567,44 @@ var transpileExpression = ({
     const message = error.message;
     throw Error(`${message} in ${JSON.stringify(expression)}`);
   }
+  const assignmentTargetMemberRanges = [];
+  if (executable) {
+    simple(root, {
+      AssignmentExpression(node) {
+        walkAssignmentTarget(node.left, {
+          MemberExpression(node2) {
+            assignmentTargetMemberRanges.push([node2.start, node2.end]);
+          }
+        });
+      }
+    });
+  }
   const replacements = [];
+  const replacementIndexByRange = /* @__PURE__ */ new Map();
+  const addReplacement = (start, end, fragment, { replaceExisting = false } = {}) => {
+    const range = `${start}:${end}`;
+    const existingIndex = replacementIndexByRange.get(range);
+    if (existingIndex !== void 0) {
+      if (replaceExisting) {
+        replacements[existingIndex] = [start, end, fragment];
+      }
+      return;
+    }
+    replacementIndexByRange.set(range, replacements.length);
+    replacements.push([start, end, fragment]);
+  };
   const replaceIdentifier = (node, assignee) => {
     const newName = replaceVariable?.(node.name, assignee);
     if (newName) {
-      replacements.push([node.start, node.end, newName]);
+      addReplacement(node.start, node.end, newName, {
+        replaceExisting: assignee
+      });
     }
   };
   simple(root, {
     Identifier: (node) => replaceIdentifier(node, false),
     AssignmentExpression(node) {
-      simple(node.left, {
+      walkAssignmentTarget(node.left, {
         Identifier: (node2) => replaceIdentifier(node2, true)
       });
     },
@@ -2334,13 +2612,18 @@ var transpileExpression = ({
       if (executable === false || node.optional) {
         return;
       }
+      if (assignmentTargetMemberRanges.some(
+        ([start, end]) => start === node.start && end === node.end
+      )) {
+        return;
+      }
       if (node.computed === false) {
         const dotIndex = expression.indexOf(".", node.object.end);
-        replacements.push([dotIndex, dotIndex, "?"]);
+        addReplacement(dotIndex, dotIndex, "?");
       }
       if (node.computed === true) {
         const dotIndex = expression.indexOf("[", node.object.end);
-        replacements.push([dotIndex, dotIndex, "?."]);
+        addReplacement(dotIndex, dotIndex, "?.");
       }
     },
     CallExpression(node) {
@@ -2350,7 +2633,7 @@ var transpileExpression = ({
       if (node.callee.type === "MemberExpression") {
         const openParenIndex = expression.indexOf("(", node.callee.end);
         if (openParenIndex !== -1) {
-          replacements.push([openParenIndex, openParenIndex, "?."]);
+          addReplacement(openParenIndex, openParenIndex, "?.");
         }
       }
     }
@@ -2474,6 +2757,8 @@ var isAbsoluteUrl = (href) => {
 
 // src/page-utils.ts
 var ROOT_FOLDER_ID = "root";
+var isPage = (page) => page !== void 0 && "path" in page;
+var isPageTemplate = (page) => page !== void 0 && !("path" in page);
 var isRootFolder = ({ id }) => id === ROOT_FOLDER_ID;
 var getPageById = (pages, pageId) => {
   return pages.pages.get(pageId);
@@ -2494,14 +2779,20 @@ var getHomePage = (pages) => {
   }
   return homePage;
 };
-var findPageByIdOrPath = (idOrPath, pages) => {
+function findPageByIdOrPath(idOrPath, pages, options = {}) {
   if (idOrPath === "" || idOrPath === "/" || idOrPath === pages.homePageId) {
     return getHomePage(pages);
   }
-  return getAllPages(pages).find(
+  const found = getAllPages(pages).find(
     (page) => page.id === idOrPath || getPagePath(page.id, pages) === idOrPath
   );
-};
+  if (found) {
+    return found;
+  }
+  if (options.includeTemplates) {
+    return pages.pageTemplates?.get(idOrPath);
+  }
+}
 var findParentFolderByChildId = (id, folders) => {
   const folderList = folders instanceof Map ? folders.values() : folders;
   for (const folder of folderList) {
@@ -2826,6 +3117,12 @@ var generatePageMeta = ({
     usedDataSources,
     scope: localScope
   });
+  const contentExpression = generateExpression({
+    expression: page.meta.content ?? "undefined",
+    dataSources,
+    usedDataSources,
+    scope: localScope
+  });
   let customExpression = "";
   customExpression += `[
 `;
@@ -2834,7 +3131,7 @@ var generatePageMeta = ({
       continue;
     }
     const propertyExpression = JSON.stringify(customMeta.property);
-    const contentExpression = generateExpression({
+    const contentExpression2 = generateExpression({
       expression: customMeta.content,
       dataSources,
       usedDataSources,
@@ -2844,7 +3141,7 @@ var generatePageMeta = ({
 `;
     customExpression += `        property: ${propertyExpression},
 `;
-    customExpression += `        content: ${contentExpression},
+    customExpression += `        content: ${contentExpression2},
 `;
     customExpression += `      },
 `;
@@ -2909,6 +3206,8 @@ var generatePageMeta = ({
   generated += `    status: ${statusExpression},
 `;
   generated += `    redirect: ${redirectExpression},
+`;
+  generated += `    content: ${contentExpression},
 `;
   generated += `    custom: ${customExpression},
 `;
@@ -2919,6 +3218,29 @@ var generatePageMeta = ({
   return generated;
 };
 
+// src/link-utils.ts
+var isInternalHref = (href, assetBaseUrl) => /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i.test(href) === false && (assetBaseUrl !== "" && href.startsWith("/") && href.startsWith(assetBaseUrl)) === false;
+var resolveLocalLinkUrl = (href, location, resolvedPath) => {
+  if (href === "") {
+    return {
+      pathname: location.pathname,
+      search: location.search,
+      hash: ""
+    };
+  }
+  if (href.startsWith("#")) {
+    return {
+      pathname: location.pathname,
+      search: location.search,
+      hash: href === "#" ? "" : href
+    };
+  }
+  return resolvedPath;
+};
+var isLocalLinkActive = (current, target) => {
+  return current.pathname === target.pathname && current.search === target.search && current.hash === target.hash;
+};
+
 // src/css.ts
 import { kebabCase } from "change-case";
 import {
@@ -2980,22 +3302,19 @@ var generateCss = ({
   const scope = createScope([], normalizeClassName, "-");
   const tagsByComponent = /* @__PURE__ */ new Map();
   tagsByComponent.set(rootComponent, /* @__PURE__ */ new Set(["html"]));
-  const tagByInstanceId = /* @__PURE__ */ new Map();
-  for (const prop of props.values()) {
-    if (prop.type === "string" && prop.name === "tag") {
-      tagByInstanceId.set(prop.instanceId, prop.value);
-    }
-  }
+  const htmlTagsByInstanceId = getHtmlTagsFromProps(props);
   for (const instance of instances.values()) {
-    const propTag = tagByInstanceId.get(instance.id);
-    const meta = componentMetas.get(instance.component);
-    const metaTag = Object.keys(meta?.presetStyle ?? {}).at(0);
     let componentTags = tagsByComponent.get(instance.component);
     if (componentTags === void 0) {
       componentTags = /* @__PURE__ */ new Set();
       tagsByComponent.set(instance.component, componentTags);
     }
-    const tag = instance.tag ?? propTag ?? metaTag;
+    const tag = getHtmlTagFromInstance({
+      instance,
+      metas: componentMetas,
+      props,
+      htmlTagsByInstanceId
+    });
     if (tag) {
       componentTags.add(tag);
     }
@@ -3153,10 +3472,12 @@ export {
   Instances,
   MIME_CATEGORIES,
   OldPagePath,
+  PageAuth,
   PageId,
   PageName,
   PagePath,
   PageRedirect,
+  PageTemplate,
   PageTitle,
   Pages,
   PresetStyleDecl,
@@ -3225,8 +3546,11 @@ export {
   getAssetMime,
   getAssetUrl,
   getExpressionIdentifiers,
+  getExpressionValueKind,
   getFolderById,
   getHomePage,
+  getHtmlTagFromInstance,
+  getHtmlTagsFromProps,
   getIndexesWithinAncestors,
   getMimeTypeByExtension,
   getMimeTypeByFilename,
@@ -3241,7 +3565,11 @@ export {
   isAllowedMimeCategory,
   isComponentDetachable,
   isCoreComponent,
+  isInternalHref,
   isLiteralExpression,
+  isLocalLinkActive,
+  isPage,
+  isPageTemplate,
   isPathnamePattern,
   isRootFolder,
   lintExpression,
@@ -3251,6 +3579,7 @@ export {
   portalComponent,
   rangeUnitValueSchema,
   replaceFormActionsWithResources,
+  resolveLocalLinkUrl,
   rootComponent,
   scrollAnimationSchema,
   systemParameter,

package/lib/link-utils.js

@@ -0,0 +1,27 @@
+// src/link-utils.ts
+var isInternalHref = (href, assetBaseUrl) => /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i.test(href) === false && (assetBaseUrl !== "" && href.startsWith("/") && href.startsWith(assetBaseUrl)) === false;
+var resolveLocalLinkUrl = (href, location, resolvedPath) => {
+  if (href === "") {
+    return {
+      pathname: location.pathname,
+      search: location.search,
+      hash: ""
+    };
+  }
+  if (href.startsWith("#")) {
+    return {
+      pathname: location.pathname,
+      search: location.search,
+      hash: href === "#" ? "" : href
+    };
+  }
+  return resolvedPath;
+};
+var isLocalLinkActive = (current, target) => {
+  return current.pathname === target.pathname && current.search === target.search && current.hash === target.hash;
+};
+export {
+  isInternalHref,
+  isLocalLinkActive,
+  resolveLocalLinkUrl
+};

package/lib/types/expression.d.ts

@@ -9,12 +9,19 @@ export type Diagnostic = {
     severity: "error" | "hint" | "info" | "warning";
     message: string;
 };
+export type VariableValues = ReadonlyMap<Identifier["name"], unknown> | Readonly<Record<Identifier["name"], unknown>>;
+export type ExpressionValueKind = "array" | "bigint" | "boolean" | "nullish" | "number" | "object" | "string" | "unknown";
 export declare const allowedStringMethods: Set<string>;
 export declare const allowedArrayMethods: Set<string>;
-export declare const lintExpression: ({ expression, availableVariables, allowAssignment, }: {
+export declare const getExpressionValueKind: ({ expression, variableValues, }: {
+    expression: string;
+    variableValues?: VariableValues;
+}) => ExpressionValueKind;
+export declare const lintExpression: ({ expression, availableVariables, allowAssignment, variableValues, }: {
     expression: string;
     availableVariables?: Set<Identifier["name"]>;
     allowAssignment?: boolean;
+    variableValues?: VariableValues;
 }) => Diagnostic[];
 /**
  * check whether provided expression is a literal value