@webstudio-is/protocol 0.271.0

package/lib/fixtures.js

@@ -0,0 +1,411 @@
+// 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 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]
+);
+
+// src/fixtures.ts
+var createPageFixture = (overrides = {}) => ({
+  id: "home",
+  name: "Home",
+  path: "",
+  title: "Home",
+  meta: {},
+  rootInstanceId: "root",
+  ...overrides
+});
+var createImageAssetFixture = (overrides = {}) => ({
+  id: "asset-1",
+  projectId: "source-project",
+  name: "image.png",
+  type: "image",
+  createdAt: "2024-01-01T00:00:00.000Z",
+  format: "png",
+  size: 100,
+  meta: { width: 100, height: 100 },
+  ...overrides
+});
+var createSerializedBuildFixture = ({
+  pages,
+  ...overrides
+} = {}) => {
+  const page = createPageFixture();
+  return {
+    id: "build-1",
+    projectId: "source-project",
+    version: 1,
+    createdAt: "2024-01-01T00:00:00.000Z",
+    updatedAt: "2024-01-01T00:00:00.000Z",
+    pages: {
+      homePageId: page.id,
+      rootFolderId: "root-folder",
+      pages: [page],
+      folders: [
+        {
+          id: "root-folder",
+          name: "Root",
+          slug: "",
+          children: [page.id]
+        }
+      ],
+      ...pages
+    },
+    breakpoints: [],
+    styles: [],
+    styleSources: [],
+    styleSourceSelections: [],
+    props: [],
+    instances: [],
+    dataSources: [],
+    resources: [],
+    ...overrides
+  };
+};
+var createPublishedProjectBundleFixture = (options = {}) => {
+  const {
+    assets,
+    build,
+    buildPages,
+    page: pageOverrides,
+    pages,
+    ...overrides
+  } = options;
+  const page = createPageFixture(pageOverrides);
+  return {
+    bundleVersion,
+    origin: "https://example.com",
+    projectDomain: "example",
+    projectTitle: "Example",
+    page,
+    pages: "pages" in options ? pages : [page],
+    assets: "assets" in options ? assets : [],
+    build: createSerializedBuildFixture({
+      ...build,
+      pages: {
+        homePageId: page.id,
+        pages: [page],
+        folders: [
+          {
+            id: "root-folder",
+            name: "Root",
+            slug: "",
+            children: [page.id]
+          }
+        ],
+        ...build?.pages,
+        ...buildPages
+      }
+    }),
+    ...overrides
+  };
+};
+export {
+  createImageAssetFixture,
+  createPageFixture,
+  createPublishedProjectBundleFixture,
+  createSerializedBuildFixture
+};