@supernova-studio/client 1.96.6 → 1.96.7

package/src/utils/figma.ts

@@ -0,0 +1,72 @@
+const figmaFileIdRegex = /^[0-9a-zA-Z]{22,128}$/;
+const nodeIdRegex = /^\d+-\d+$/;
+const nodeTypeRegex = /^[0-9a-zA-Z]^/;
+
+export enum ParsedFigmaFileURLError {
+  InvalidUrl = "InvalidUrl",
+  InvalidFigmaFileId = "InvalidFigmaFileId",
+}
+
+type ParsedFigmaFileURL =
+  | {
+      status: "Success";
+      fileId: string;
+      fileName: string | null;
+      nodeId: string | null;
+      nodeType: string | null;
+    }
+  | {
+      status: "Error";
+      error: ParsedFigmaFileURLError;
+    };
+
+export const FigmaUtils = {
+  tryParseFigmaFileURL(urlString: string): ParsedFigmaFileURL {
+    if (!URL.canParse(urlString)) {
+      return { status: "Error", error: ParsedFigmaFileURLError.InvalidUrl };
+    }
+
+    // Validate that this is a Figma URL
+    const url = new URL(urlString);
+    if (!url.hostname.endsWith("figma.com")) {
+      return { status: "Error", error: ParsedFigmaFileURLError.InvalidUrl };
+    }
+
+    // Validate that the URL type is the correct one (pointing to a design file)
+    const pathSegments = url.pathname.split("/");
+    if (pathSegments[1] !== "design" && pathSegments[1] !== "file") {
+      return { status: "Error", error: ParsedFigmaFileURLError.InvalidUrl };
+    }
+
+    // Validate Figma file ID
+    const fileId = pathSegments[2];
+    if (!fileId || !fileId.match(figmaFileIdRegex)) {
+      return { status: "Error", error: ParsedFigmaFileURLError.InvalidFigmaFileId };
+    }
+
+    // Parse Figma file name
+    let fileName: string | null = null;
+    const rawFileName = pathSegments[3];
+    if (rawFileName) {
+      fileName = rawFileName.replaceAll("-", " ");
+    }
+
+    // Parse node id
+    let nodeId: string | null = null;
+    const nodeIdRaw = url.searchParams.get("node-id");
+    if (nodeIdRaw && nodeIdRaw.match(nodeIdRegex)) {
+      nodeId = nodeIdRaw.replace("-", ":");
+    }
+
+    // Parse node type
+    let nodeType: string | null = null;
+    const nodeTypeRaw = url.searchParams.get("node-type");
+    if (nodeTypeRaw && nodeTypeRaw.match(nodeTypeRegex)) {
+      nodeType = nodeTypeRaw;
+    }
+
+    return { status: "Success", fileId, fileName, nodeId, nodeType };
+  },
+};
+
+// https://www.figma.com/design/U3Mg3I8WbvqF6CcZtRJM7w?node-id=2-3&t=9Qev2vhsldyFMhuE-1

package/src/utils/hash.ts

@@ -0,0 +1,62 @@
+function hash(input: string): string {
+  return farmhash(input).toString(16);
+}
+
+function farmhash(input: string): number {
+  const seed = 0x9e3779b9;
+  let hash = seed;
+
+  for (let i = 0; i < input.length; i++) {
+    const charCode = input.charCodeAt(i);
+    hash ^= charCode;
+    hash = Math.imul(hash, 0x5bd1e995);
+    hash ^= hash >>> 15;
+  }
+
+  hash = Math.imul(hash, 0x5bd1e995);
+  hash ^= hash >>> 13;
+  hash = Math.imul(hash, 0x5bd1e995);
+  hash ^= hash >>> 15;
+
+  return hash >>> 0;
+}
+
+function prepareObject(obj: any): any {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(prepareObject);
+  }
+  const sortedObj: any = {};
+  for (const key of Object.keys(obj).sort()) {
+    if (obj[key] === null || obj[key] === undefined) {
+      continue;
+    }
+    sortedObj[key] = prepareObject(obj[key]);
+  }
+  return sortedObj;
+}
+
+export function generateHash(input: object | string, debug = false): string {
+  if (typeof input === "object") {
+    const sanitized = JSON.stringify(prepareObject(input));
+    if (debug) {
+      console.log("Hashing sanitized string:");
+      console.log(sanitized);
+    }
+    return hash(sanitized);
+  } else {
+    try {
+      const obj = JSON.parse(input);
+      const sanitized = JSON.stringify(prepareObject(obj));
+      if (debug) {
+        console.log("Hashing sanitized string:");
+        console.log(sanitized);
+      }
+      return hash(sanitized);
+    } catch {
+      return hash(input);
+    }
+  }
+}

package/src/utils/index.ts

@@ -0,0 +1,4 @@
+export * from "./figma";
+export * from "./hash";
+export * from "./query";
+export * from "./redirect-validation";

package/src/utils/query.ts

@@ -0,0 +1,41 @@
+import z from "zod";
+
+type CompatibleValue = number | string | boolean | undefined;
+type QueryObject = Record<string, CompatibleValue | CompatibleValue[]>;
+
+export function serializeQuery(query: QueryObject): URLSearchParams {
+  const queryWithStrings = Object.fromEntries(
+    Object.entries(query)
+      .filter(e => !!e[1])
+      .map(([k, v]) => {
+        if (Array.isArray(v)) {
+          return [k, v.join(", ")];
+        } else {
+          return [k, v!.toString()];
+        }
+      })
+  );
+
+  return new URLSearchParams(queryWithStrings);
+}
+
+export function zodQueryBoolean() {
+  return z
+    .string()
+    .optional()
+    .transform(string => {
+      // Not provided
+      if (!string) return undefined;
+
+      const lc = string.toLowerCase();
+
+      // False
+      if (lc === "0" || lc === "false") return false;
+
+      // True
+      if (lc === "1" || lc === "true") return true;
+
+      // Unknown
+      return undefined;
+    });
+}

package/src/utils/redirect-validation.ts

@@ -0,0 +1,76 @@
+export const exhaustiveInvalidUriPaths = {
+  emptyPath: "",
+  spacesInPath: "/invalid path/with spaces",
+  specialCharacter1: "/path/with|invalid>characters",
+  specialCharacter2: "/path/with<invalid*characters",
+  specialCharacter3: "/path/{invalid}?characters",
+  consecutiveSlashes: "/path//with///too/many/slashes",
+  unencodedPercent: "/path/with/unencoded%percent",
+  unencodedSpaces: "/path/with unencoded spaces",
+  fragmentIdentifier: "/path/with#fragment",
+  queryParameters: "/path/with?query=parameter",
+  nullCharacter: "/path/with/\u0000nullcharacter",
+  onlySlash: "/",
+  controlCharacter: "/path/with/control\0character",
+  extremelyLongPath: "/" + "a".repeat(2047),
+  invalidStartCharacter: "///path/starting/with/slashes",
+  invalidStartCharacterColon: ":/path/starting/with/colon",
+  invalidTrailingDot: "/path/ending/with/dot.",
+  invalidPercentEncoding1: "/path/with/%2",
+  invalidPercentEncoding2: "/path/with/%ZZ",
+  invalidPercentEncoding3: "/path/with/%G1",
+  reservedCharacter1: "/path/with?<reserved>",
+  reservedCharacter2: '/path/with/"quotes"',
+  reservedCharacter3: "/path/with/[brackets]",
+  reservedCharacter4: "/path/with/\\backslashes",
+  nonAscii1: "/path/with/你好",
+  nonAscii2: "/path/with/emoji/😃",
+  mixedEncodingPath: "/path/%41A%42B%C3%28",
+  directoryTraversal1: "/path/../../etc/passwd",
+  directoryTraversal2: "/path/./././",
+};
+
+type ValidationErrorReason = "TooLong" | "InvalidURI" | "Empty" | "ContainsQuery" | "ContainsFragment";
+
+export function isValidRedirectPath(path: string): { isValid: boolean; reason: ValidationErrorReason | undefined } {
+  const trimmedPath = path.toLowerCase().trim();
+  const url = "https://www.example.com" + trimmedPath;
+  if (url.length > 2048) {
+    return {
+      isValid: false,
+      reason: "TooLong",
+    };
+  }
+  if (trimmedPath === "") {
+    return {
+      isValid: false,
+      reason: "Empty",
+    };
+  }
+  if (url === "/") {
+    return {
+      isValid: false,
+      reason: "Empty",
+    };
+  }
+
+  if (url.includes("?")) {
+    return {
+      isValid: false,
+      reason: "ContainsQuery",
+    };
+  }
+  if (url.includes("#")) {
+    return {
+      isValid: false,
+      reason: "ContainsFragment",
+    };
+  }
+
+  const regex = /^\/[A-Za-z0-9_-]+(\/[A-Za-z0-9_-]+)*$/;
+  const isValid = regex.test(trimmedPath);
+  return {
+    isValid: regex.test(trimmedPath),
+    reason: !isValid ? "InvalidURI" : undefined,
+  };
+}

package/src/yjs/design-system-content/documentation-hierarchy.ts

@@ -0,0 +1,35 @@
+import * as Y from "yjs";
+import { z } from "zod";
+import { DTODocumentationHierarchyV2 } from "../../api";
+import { FrontendVersionRoomYDoc } from "../version-room/frontend";
+
+// We store pages and groups in the same way they are stored in the database.
+// This means that instead of groups having childrenIds array, all items have
+// parentPersistentId property that points to the parent item in the tree.
+// Upon read this gets converted to the format that client expects, which is
+// ordered childrenIds array on all groups.
+//
+// The decision behind it is that we potentially want to get rid of childrenIds
+// array entirely because it makes group updates more complicated. For now
+// resolving it on fly is a tradeoff for not rewriting client to stop relying
+// on children ids array.
+
+//
+// Types
+//
+
+export const DocumentationHierarchySettings = z.object({
+  routingVersion: z.string(),
+  isDraftFeatureAdopted: z.boolean(),
+  isApprovalFeatureEnabled: z.boolean(),
+  approvalRequiredForPublishing: z.boolean(),
+});
+
+export type DocumentationHierarchySettings = z.infer<typeof DocumentationHierarchySettings>;
+
+/**
+ * @deprecated - Use FrontendVersionRoomYDoc.getDocumentationHierarchy
+ */
+export function yjsToDocumentationHierarchy(doc: Y.Doc): DTODocumentationHierarchyV2 {
+  return new FrontendVersionRoomYDoc(doc).getDocumentationHierarchy();
+}

package/src/yjs/design-system-content/index.ts

@@ -0,0 +1,2 @@
+export * from "./documentation-hierarchy";
+export * from "./item-configuration";

package/src/yjs/design-system-content/item-configuration.ts

@@ -0,0 +1,62 @@
+import { DocumentationItemHeaderV2 } from "@supernova-studio/model";
+import * as Y from "yjs";
+import { z } from "zod";
+import { DTODocumentationItemConfigurationV2 } from "../../api/dto/elements/documentation/item-configuration-v2";
+
+//
+// Types
+//
+
+export const DTODocumentationPageRoomHeaderData = z.object({
+  title: z.string(),
+  configuration: DTODocumentationItemConfigurationV2,
+});
+
+export const DTODocumentationPageRoomHeaderDataUpdate = z.object({
+  title: z.string().optional(),
+  configuration: DTODocumentationItemConfigurationV2.omit({ header: true })
+    .extend({ header: DocumentationItemHeaderV2.partial() })
+    .optional(),
+});
+
+export type DTODocumentationPageRoomHeaderData = z.infer<typeof DTODocumentationPageRoomHeaderData>;
+export type DTODocumentationPageRoomHeaderDataUpdate = z.infer<typeof DTODocumentationPageRoomHeaderDataUpdate>;
+
+//
+// YJS Bindings
+//
+
+export function itemConfigurationToYjs(yDoc: Y.Doc, item: DTODocumentationPageRoomHeaderDataUpdate) {
+  yDoc.transact(trx => {
+    const { title, configuration } = item;
+
+    const header = configuration?.header;
+
+    if (title !== undefined) {
+      const headerYMap = trx.doc.getMap("itemTitle");
+      headerYMap.set("title", title);
+    }
+
+    if (header) {
+      const headerYMap = trx.doc.getMap("itemHeader");
+
+      header.description !== undefined && headerYMap.set("description", header.description);
+      header.alignment !== undefined && headerYMap.set("alignment", header.alignment);
+      header.foregroundColor !== undefined && headerYMap.set("foregroundColor", header.foregroundColor);
+      header.backgroundColor !== undefined && headerYMap.set("backgroundColor", header.backgroundColor);
+      header.backgroundImageAsset !== undefined && headerYMap.set("backgroundImageAsset", header.backgroundImageAsset);
+      header.backgroundImageScaleType !== undefined &&
+        headerYMap.set("backgroundImageScaleType", header.backgroundImageScaleType);
+      header.showBackgroundOverlay !== undefined &&
+        headerYMap.set("showBackgroundOverlay", header.showBackgroundOverlay);
+      header.showCoverText !== undefined && headerYMap.set("showCoverText", header.showCoverText);
+      header.minHeight !== undefined && headerYMap.set("minHeight", header.minHeight);
+    }
+
+    const configYMap = trx.doc.getMap("itemConfiguration");
+
+    configuration?.showSidebar !== undefined && configYMap.set("showSidebar", configuration.showSidebar);
+    configuration?.isHidden !== undefined && configYMap.set("isHidden", configuration.isHidden);
+    configuration?.isPrivate !== undefined && configYMap.set("isPrivate", configuration.isPrivate);
+  });
+}