@webstudio-is/protocol 0.271.0

package/lib/index.js

@@ -0,0 +1,335 @@
+// src/schema.ts
+import { Asset, Page } from "@webstudio-is/sdk/schema";
+import { SerializedBuildSchema } from "@webstudio-is/project-build/schema";
+import { wsAuthConfigSchema } from "@webstudio-is/wsauth/schema";
+import { z as z2 } from "zod";
+
+// package.json
+var package_default = {
+  name: "@webstudio-is/protocol",
+  version: "0.271.0",
+  description: "Webstudio data exchange protocol contracts",
+  author: "Webstudio <github@webstudio.is>",
+  homepage: "https://webstudio.is",
+  type: "module",
+  scripts: {
+    build: "rm -rf lib && esbuild src/index.ts src/fixtures.ts --outdir=lib --bundle --format=esm --packages=external",
+    dts: "tsc --project tsconfig.dts.json",
+    test: "vitest run",
+    typecheck: "tsgo --noEmit"
+  },
+  dependencies: {
+    "@webstudio-is/project-build": "workspace:*",
+    "@webstudio-is/sdk": "workspace:*",
+    "@webstudio-is/wsauth": "workspace:*",
+    zod: "^3.24.2"
+  },
+  devDependencies: {
+    "@webstudio-is/tsconfig": "workspace:*",
+    vitest: "^3.1.2"
+  },
+  exports: {
+    ".": {
+      webstudio: "./src/index.ts",
+      types: "./lib/types/index.d.ts",
+      import: "./lib/index.js",
+      default: "./src/index.ts"
+    },
+    "./fixtures": {
+      webstudio: "./src/fixtures.ts",
+      types: "./lib/types/fixtures.d.ts",
+      import: "./lib/fixtures.js",
+      default: "./src/fixtures.ts"
+    }
+  },
+  files: [
+    "lib/*",
+    "!*.{test,stories}.*"
+  ],
+  license: "AGPL-3.0-or-later",
+  private: false,
+  sideEffects: false
+};
+
+// src/contract-version.ts
+import { z } from "zod";
+var getFunctionContract = (value) => {
+  if (typeof value !== "function") {
+    return;
+  }
+  const contractFunction = value;
+  if (contractFunction.contract !== void 0) {
+    return { contract: contractFunction.contract };
+  }
+  return { contract: "unversioned-function" };
+};
+var getSchemaContract = (schema, seen = /* @__PURE__ */ new Map()) => {
+  const schemaId = seen.get(schema);
+  if (schemaId !== void 0) {
+    return { type: "ref", id: schemaId };
+  }
+  seen.set(schema, seen.size);
+  const definition = schema._def;
+  switch (definition.typeName) {
+    case z.ZodFirstPartyTypeKind.ZodArray:
+      return {
+        type: "array",
+        value: getSchemaContract(definition.type, seen),
+        checks: {
+          exactLength: definition.exactLength,
+          maxLength: definition.maxLength,
+          minLength: definition.minLength
+        }
+      };
+    case z.ZodFirstPartyTypeKind.ZodBoolean:
+      return {
+        type: "boolean"
+      };
+    case z.ZodFirstPartyTypeKind.ZodDefault:
+      return {
+        type: "default",
+        value: getSchemaContract(definition.innerType, seen)
+      };
+    case z.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
+      return {
+        type: "discriminatedUnion",
+        discriminator: definition.discriminator,
+        options: definition.options.map(
+          (option) => getSchemaContract(option, seen)
+        )
+      };
+    case z.ZodFirstPartyTypeKind.ZodEffects:
+      return {
+        type: "effects",
+        effect: definition.effect.type,
+        source: getFunctionContract(
+          definition.effect.refinement ?? definition.effect.transform
+        ),
+        value: getSchemaContract(definition.schema, seen)
+      };
+    case z.ZodFirstPartyTypeKind.ZodEnum:
+      return {
+        type: "enum",
+        values: definition.values
+      };
+    case z.ZodFirstPartyTypeKind.ZodLiteral:
+      return {
+        type: "literal",
+        value: definition.value
+      };
+    case z.ZodFirstPartyTypeKind.ZodLazy:
+      return {
+        type: "lazy",
+        value: getSchemaContract(definition.getter(), seen)
+      };
+    case z.ZodFirstPartyTypeKind.ZodMap:
+      return {
+        type: "map",
+        key: getSchemaContract(definition.keyType, seen),
+        value: getSchemaContract(definition.valueType, seen)
+      };
+    case z.ZodFirstPartyTypeKind.ZodNativeEnum:
+      return {
+        type: "nativeEnum",
+        values: definition.values
+      };
+    case z.ZodFirstPartyTypeKind.ZodNever:
+      return {
+        type: "never"
+      };
+    case z.ZodFirstPartyTypeKind.ZodNull:
+      return {
+        type: "null"
+      };
+    case z.ZodFirstPartyTypeKind.ZodNullable:
+      return {
+        type: "nullable",
+        value: getSchemaContract(definition.innerType, seen)
+      };
+    case z.ZodFirstPartyTypeKind.ZodNumber:
+      return {
+        type: "number",
+        checks: definition.checks
+      };
+    case z.ZodFirstPartyTypeKind.ZodObject:
+      return {
+        type: "object",
+        unknownKeys: definition.unknownKeys,
+        catchall: getSchemaContract(definition.catchall, seen),
+        shape: Object.fromEntries(
+          Object.entries(definition.shape()).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => [
+            key,
+            getSchemaContract(value, seen)
+          ])
+        )
+      };
+    case z.ZodFirstPartyTypeKind.ZodOptional:
+      return {
+        type: "optional",
+        value: getSchemaContract(definition.innerType, seen)
+      };
+    case z.ZodFirstPartyTypeKind.ZodRecord:
+      return {
+        type: "record",
+        key: getSchemaContract(definition.keyType, seen),
+        value: getSchemaContract(definition.valueType, seen)
+      };
+    case z.ZodFirstPartyTypeKind.ZodString:
+      return {
+        type: "string",
+        checks: definition.checks
+      };
+    case z.ZodFirstPartyTypeKind.ZodTuple:
+      return {
+        type: "tuple",
+        items: definition.items.map(
+          (item) => getSchemaContract(item, seen)
+        ),
+        rest: definition.rest === null ? void 0 : getSchemaContract(definition.rest, seen)
+      };
+    case z.ZodFirstPartyTypeKind.ZodUndefined:
+      return {
+        type: "undefined"
+      };
+    case z.ZodFirstPartyTypeKind.ZodUnknown:
+      return {
+        type: "unknown"
+      };
+    case z.ZodFirstPartyTypeKind.ZodUnion:
+      return {
+        type: "union",
+        options: definition.options.map(
+          (option) => getSchemaContract(option, seen)
+        )
+      };
+    default:
+      throw new Error(
+        `Unsupported schema contract type: ${definition.typeName}`
+      );
+  }
+};
+var stableStringify = (value) => {
+  if (value === void 0) {
+    return "undefined";
+  }
+  if (value instanceof RegExp) {
+    return stableStringify({
+      source: value.source,
+      flags: value.flags
+    });
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify).join(",")}]`;
+  }
+  if (value !== null && typeof value === "object") {
+    return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+};
+var createContractVersion = (schema, version, additionalSchemas = []) => {
+  const bundlePackageVersion = version.replace(/-webstudio-version$/, "");
+  let hash = 2166136261;
+  for (const char of stableStringify({
+    additionalSchemas: additionalSchemas.map(
+      (schema2) => getSchemaContract(schema2)
+    ),
+    schema: getSchemaContract(schema)
+  })) {
+    hash ^= char.charCodeAt(0);
+    hash = Math.imul(hash, 16777619);
+  }
+  return `bundle-${bundlePackageVersion}-${(hash >>> 0).toString(16).padStart(8, "0")}`;
+};
+
+// src/schema.ts
+var assetFileDataPattern = /^[A-Za-z0-9+/]*={0,2}$/;
+var isAssetFileDataString = (value) => {
+  if (value.length % 4 !== 0) {
+    return false;
+  }
+  if (assetFileDataPattern.test(value) === false) {
+    return false;
+  }
+  const paddingIndex = value.indexOf("=");
+  return paddingIndex === -1 || paddingIndex >= value.length - 2;
+};
+var assertAssetFileDataString = Object.assign(
+  (value, context) => {
+    if (isAssetFileDataString(value)) {
+      return;
+    }
+    context.addIssue({
+      code: z2.ZodIssueCode.custom,
+      message: "Invalid asset file data"
+    });
+  },
+  {
+    contract: {
+      encoding: "base64",
+      length: "multiple-of-4",
+      padding: "only-last-two-characters",
+      pattern: assetFileDataPattern
+    }
+  }
+);
+var assetFileNameSchema = z2.string().min(1).regex(/^(?!\.{1,2}$)[^/\\]+$/);
+var isAssetFileName = (value) => assetFileNameSchema.safeParse(value).success;
+var assetFileDataSchema = z2.object({
+  name: assetFileNameSchema,
+  data: z2.string().superRefine(assertAssetFileDataString)
+});
+var projectBundleSchema = z2.object({
+  page: Page,
+  pages: z2.array(Page),
+  build: SerializedBuildSchema,
+  assets: z2.array(Asset),
+  origin: z2.string().optional()
+});
+var publishedProjectBundleSchema = projectBundleSchema.extend({
+  bundleVersion: z2.union([z2.string(), z2.number()]).optional(),
+  user: z2.object({ email: z2.string().nullable() }).optional(),
+  projectDomain: z2.string(),
+  projectTitle: z2.string()
+});
+var importProjectBundleInputSchema = z2.object({
+  projectId: z2.string(),
+  data: publishedProjectBundleSchema,
+  assetFiles: z2.array(assetFileDataSchema).optional(),
+  ignoreVersionCheck: z2.boolean().optional()
+});
+var importProjectBundleResultSchema = z2.object({
+  version: z2.number()
+});
+var checkProjectBuildPermissionInputSchema = z2.object({
+  projectId: z2.string()
+});
+var bundleVersion = createContractVersion(
+  publishedProjectBundleSchema,
+  package_default.version,
+  [wsAuthConfigSchema]
+);
+var getBundleVersion = (data) => {
+  if (typeof data !== "object" || data === null) {
+    return;
+  }
+  const version = data.bundleVersion;
+  return typeof version === "number" || typeof version === "string" ? version : void 0;
+};
+var getBundleVersionMismatchMessage = ({
+  ignoreVersionCheckHint,
+  receivedVersion
+}) => `Project bundle format is incompatible. Expected version ${bundleVersion}, received ${receivedVersion ?? "missing"}. Sync with a compatible API/CLI version and retry, or ${ignoreVersionCheckHint}.`;
+export {
+  assetFileDataPattern,
+  assetFileDataSchema,
+  bundleVersion,
+  checkProjectBuildPermissionInputSchema,
+  getBundleVersion,
+  getBundleVersionMismatchMessage,
+  importProjectBundleInputSchema,
+  importProjectBundleResultSchema,
+  isAssetFileDataString,
+  isAssetFileName,
+  projectBundleSchema,
+  publishedProjectBundleSchema
+};

package/lib/types/contract-version.d.ts

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export declare const createContractVersion: (schema: z.ZodTypeAny, version: string, additionalSchemas?: z.ZodTypeAny[]) => `bundle-${string}-${string}`;

package/lib/types/fixtures.d.ts

@@ -0,0 +1,22 @@
+import type { Asset, Page } from "@webstudio-is/sdk/schema";
+import { type PublishedProjectBundle } from "./schema";
+type SerializedBuild = PublishedProjectBundle["build"];
+type SerializedPages = SerializedBuild["pages"];
+type ImageAsset = Extract<Asset, {
+    type: "image";
+}>;
+type SerializedBuildFixtureOptions = Partial<Omit<SerializedBuild, "pages">> & {
+    pages?: Partial<SerializedPages>;
+};
+export declare const createPageFixture: (overrides?: Partial<Page>) => Page;
+export declare const createImageAssetFixture: (overrides?: Partial<ImageAsset>) => ImageAsset;
+export declare const createSerializedBuildFixture: ({ pages, ...overrides }?: SerializedBuildFixtureOptions) => SerializedBuild;
+type PublishedProjectBundleFixtureOptions = Partial<Omit<PublishedProjectBundle, "assets" | "build" | "page" | "pages">> & {
+    build?: SerializedBuildFixtureOptions;
+    buildPages?: Partial<SerializedPages>;
+    page?: Partial<Page>;
+    assets?: Asset[];
+    pages?: Page[];
+};
+export declare const createPublishedProjectBundleFixture: (options?: PublishedProjectBundleFixtureOptions) => PublishedProjectBundle;
+export {};

package/lib/types/index.d.ts

@@ -0,0 +1 @@
+export * from "./schema";