@sanity/workbench 0.1.0-alpha.6 → 0.1.0-alpha.8

package/dist/core.js

@@ -0,0 +1,744 @@
+import { z } from "zod";
+import { createLogger, logger } from "./_chunks-es/index.js";
+import { valid, coerce, gt, lt, gte, rsort } from "semver";
+class AbstractApplication {
+  type;
+  constructor(type) {
+    this.type = type;
+  }
+  get initials() {
+    const SYMBOLS = /[^\p{Alpha}\p{N}\p{White_Space}]/gu, WHITESPACE = new RegExp("\\p{White_Space}+", "u"), ALPHANUMERIC_SEGMENTS = new RegExp("(\\p{N}+|\\p{Alpha}+)", "gu"), IS_NUMERIC = new RegExp("^\\p{N}+$", "u");
+    if (!this.title) return "";
+    const namesArray = this.title.replace(SYMBOLS, "").split(WHITESPACE).filter(Boolean);
+    if (namesArray.length === 0) return "";
+    if (namesArray.length === 1) {
+      const word = namesArray[0], segments = word.match(ALPHANUMERIC_SEGMENTS) || [];
+      return segments.length === 0 ? "" : segments.length === 1 ? word.length === 1 ? word.toUpperCase() : IS_NUMERIC.test(word) ? `${word.charAt(0)}${word.charAt(1)}`.toUpperCase() : word.charAt(0).toUpperCase() : `${segments[0].charAt(0)}${segments[1].charAt(0)}`.toUpperCase();
+    }
+    return `${namesArray[0].charAt(0)}${namesArray[namesArray.length - 1].charAt(0)}`.toUpperCase();
+  }
+}
+class LocalApplication extends AbstractApplication {
+  localApplication;
+  constructor(localApplication) {
+    super(localApplication.type), this.localApplication = localApplication;
+  }
+  get id() {
+    const { host, port } = this.localApplication;
+    return `${host}-${port}`;
+  }
+  get title() {
+    const { host, port } = this.localApplication;
+    return `${host}:${port}`;
+  }
+  get href() {
+    return `/local/${this.id}`;
+  }
+  get url() {
+    const { host, port } = this.localApplication;
+    return new URL(`http://${host}:${port}`);
+  }
+  toProtocolResource() {
+    throw new Error(
+      "LocalApplication cannot be serialized to a protocol resource"
+    );
+  }
+}
+class ApplicationList {
+  applications;
+  /**
+   * @param applications - The applications to initialize the list with.
+   */
+  constructor(applications) {
+    this.applications = [...applications];
+  }
+  findApplicationsByType(_type) {
+    const types = Array.isArray(_type) ? _type : [_type];
+    return this.applications.filter((r) => types.includes(r.type));
+  }
+  findApplication(type, id) {
+    switch (type) {
+      case "media-library":
+      case "canvas":
+        return this.applications.find((r) => r.type === type);
+      case "coreApp":
+      case "studio":
+      case "workspace":
+        return this.applications.find((r) => r.type === type && r.id === id);
+    }
+  }
+  toProtocolResources() {
+    return this.applications.reduce((acc, r) => r.type === "studio" || r instanceof LocalApplication ? acc : [...acc, r.toProtocolResource()], []);
+  }
+  static areApplicationsEqual(application1, application2) {
+    return !application1 || !application2 || application1.type !== application2.type ? !1 : application1.id === application2.id;
+  }
+}
+const OrganizationId = z.string().nonempty().brand("OrganizationId");
+function brandOrganizationId(id) {
+  return OrganizationId.parse(id);
+}
+const OrganizationMember = z.object({
+  sanityUserId: z.string(),
+  isCurrentUser: z.boolean(),
+  user: z.object({
+    id: z.string(),
+    displayName: z.string(),
+    familyName: z.string(),
+    givenName: z.string(),
+    middleName: z.string().nullable(),
+    imageUrl: z.string().nullable(),
+    email: z.string(),
+    loginProvider: z.string()
+  }),
+  roles: z.array(
+    z.object({
+      name: z.string(),
+      title: z.string(),
+      description: z.string().optional()
+    })
+  )
+}), Organization = z.object({
+  id: OrganizationId,
+  name: z.string(),
+  slug: z.string().nullable(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  dashboardStatus: z.enum(["enabled", "disabled"]),
+  aiFeaturesStatus: z.enum(["enabled", "disabled"]),
+  defaultRoleName: z.string()
+});
+function parseOrganization(data, options) {
+  const includeMembers = options?.includeMembers ?? !0, includeFeatures = options?.includeFeatures ?? !0, extensions = {
+    ...includeMembers && {
+      members: z.array(OrganizationMember)
+    },
+    ...includeFeatures && {
+      features: z.array(z.string())
+    }
+  };
+  return (Object.keys(extensions).length > 0 ? Organization.extend(extensions) : Organization).parse(data);
+}
+const CanvasId = z.string().nonempty().brand("CanvasId");
+function brandCanvasId(id) {
+  return CanvasId.parse(id);
+}
+const Canvas = z.object({
+  id: CanvasId,
+  organizationId: OrganizationId,
+  status: z.enum(["active", "provisioning"])
+});
+function parseCanvas(data) {
+  return Canvas.parse(data);
+}
+class CanvasApplication extends AbstractApplication {
+  canvas;
+  constructor(canvas) {
+    super("canvas"), this.canvas = canvas;
+  }
+  get id() {
+    return this.canvas.id;
+  }
+  get href() {
+    return "canvas";
+  }
+  get title() {
+    return "Canvas";
+  }
+  toProtocolResource() {
+    return {
+      type: "canvas",
+      id: this.id
+    };
+  }
+}
+const MediaLibraryId = z.string().nonempty().brand("MediaLibraryId");
+function brandMediaLibraryId(id) {
+  return MediaLibraryId.parse(id);
+}
+const MediaLibrary = z.object({
+  id: MediaLibraryId,
+  organizationId: OrganizationId,
+  status: z.enum(["active", "provisioning"]),
+  aclMode: z.enum(["private", "public"])
+});
+function parseMediaLibrary(data) {
+  return MediaLibrary.parse(data);
+}
+class MediaLibraryApplication extends AbstractApplication {
+  library;
+  constructor(library) {
+    super("media-library"), this.library = library;
+  }
+  get id() {
+    return this.library.id;
+  }
+  get href() {
+    return "media";
+  }
+  get title() {
+    return "Media Library";
+  }
+  toProtocolResource() {
+    return {
+      type: "media-library",
+      id: this.id
+    };
+  }
+}
+const ProjectId = z.string().nonempty().brand("ProjectId");
+function brandProjectId(id) {
+  return ProjectId.parse(id);
+}
+const ProjectMember = z.object({
+  id: z.string(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  isCurrentUser: z.boolean(),
+  isRobot: z.boolean(),
+  roles: z.array(
+    z.object({
+      name: z.string(),
+      title: z.string(),
+      description: z.string()
+    })
+  )
+}), Project = z.object({
+  id: ProjectId,
+  displayName: z.string(),
+  studioHost: z.string().nullable(),
+  organizationId: OrganizationId,
+  metadata: z.object({
+    color: z.string().optional(),
+    externalStudioHost: z.string().optional(),
+    initialTemplate: z.string().optional(),
+    cliInitializedAt: z.string().optional(),
+    integration: z.literal(["manage", "cli"])
+  }),
+  isBlocked: z.boolean(),
+  isDisabled: z.boolean(),
+  isDisabledByUser: z.boolean(),
+  activityFeedEnabled: z.boolean(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+function parseProject(data, options) {
+  const includeMembers = options?.includeMembers ?? !0, includeFeatures = options?.includeFeatures ?? !0, extensions = {
+    ...includeMembers && { members: z.array(ProjectMember) },
+    ...includeFeatures && { features: z.array(z.string()) }
+  };
+  return (Object.keys(extensions).length > 0 ? Project.extend(extensions) : Project).parse(data);
+}
+const UserApplicationId = z.string().nonempty().brand("UserApplicationId");
+function brandUserApplicationId(id) {
+  return UserApplicationId.parse(id);
+}
+const UserApplicationBase = z.object({
+  id: UserApplicationId,
+  appHost: z.string(),
+  urlType: z.enum(["internal", "external"]),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  dashboardStatus: z.enum(["default", "disabled"])
+}), ActiveDeployment = z.object({
+  id: z.string(),
+  version: z.string(),
+  isActiveDeployment: z.boolean(),
+  userApplicationId: z.string(),
+  isAutoUpdating: z.boolean(),
+  size: z.number(),
+  deployedAt: z.string(),
+  deployedBy: z.string(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+class UserApplication extends AbstractApplication {
+  application;
+  id;
+  constructor(application, type) {
+    super(type), this.application = application, this.id = brandUserApplicationId(application.id);
+  }
+  /**
+   * @returns A fully resolved URL instance for the application.
+   * For internal applications, constructs a URL using the Sanity studio domain
+   * pattern resolved from the environment at the consuming app's build time.
+   * For external applications, returns the provided app host as a URL.
+   */
+  get url() {
+    return this.application.urlType === "internal" ? import.meta.env.VITE_SANITY_ENV === "production" ? new URL(`https://${this.application.appHost}.sanity.studio`) : new URL(
+      `https://${this.application.appHost}.studio.${import.meta.env.VITE_SANITY_DOMAIN}`
+    ) : new URL(this.application.appHost);
+  }
+}
+const CoreAppUserApplicationManifest = z.object({
+  version: z.string(),
+  icon: z.string().optional(),
+  title: z.string().optional()
+}), CoreAppUserApplicationBase = UserApplicationBase.extend({
+  title: z.string(),
+  organizationId: OrganizationId,
+  type: z.literal("coreApp"),
+  manifest: CoreAppUserApplicationManifest.nullable().optional()
+}), InternalCoreAppUserApplication = CoreAppUserApplicationBase.extend({
+  urlType: z.literal("internal"),
+  activeDeployment: ActiveDeployment.extend({
+    manifest: CoreAppUserApplicationManifest.nullable().optional()
+  })
+}), ExternalCoreAppUserApplication = CoreAppUserApplicationBase.extend({
+  urlType: z.literal("external"),
+  activeDeployment: z.null()
+}), CoreAppUserApplication = z.discriminatedUnion("urlType", [
+  InternalCoreAppUserApplication,
+  ExternalCoreAppUserApplication
+]);
+function parseCoreApplication(data) {
+  return CoreAppUserApplication.parse(data);
+}
+class CoreAppApplication extends UserApplication {
+  activeDeployment;
+  constructor(application) {
+    super(application, "coreApp"), this.activeDeployment = application.activeDeployment;
+  }
+  get href() {
+    return `/application/${this.application.id}`;
+  }
+  get title() {
+    return this.activeDeployment?.manifest?.title ?? this.application.title;
+  }
+  get subtitle() {
+  }
+  get updatedAt() {
+    return this.application.updatedAt;
+  }
+  get(attr) {
+    if (!(attr in this.application))
+      throw new Error(
+        `Attribute ${attr.toString()} does not exist on application ${this.application.id}`
+      );
+    return this.application[attr];
+  }
+  toProtocolResource() {
+    return {
+      ...this.application,
+      type: "application",
+      url: this.url.toString()
+    };
+  }
+}
+const Workspace = z.object({
+  name: z.string(),
+  title: z.string(),
+  subtitle: z.string().optional(),
+  basePath: z.string(),
+  projectId: ProjectId,
+  dataset: z.string().optional(),
+  icon: z.string().nullable().optional()
+}), ServerManifest = z.object({
+  buildId: z.string().optional(),
+  bundleVersion: z.string().optional(),
+  version: z.string().optional(),
+  workspaces: z.array(
+    Workspace.extend({
+      dataset: z.string(),
+      schemaDescriptorId: z.string()
+    })
+  ).optional()
+}), ClientManifest$1 = z.object({
+  version: z.number(),
+  createdAt: z.string(),
+  studioVersion: z.string().optional(),
+  workspaces: z.array(
+    Workspace.extend({
+      schema: z.string(),
+      tools: z.string().optional()
+    })
+  )
+}), StudioUserApplicationBase = UserApplicationBase.extend({
+  title: z.string().nullable(),
+  projectId: ProjectId,
+  type: z.literal("studio"),
+  manifest: ClientManifest$1.nullable(),
+  manifestData: z.object({ value: ClientManifest$1 }).nullable(),
+  autoUpdatingVersion: z.string().nullable(),
+  config: z.object({
+    "live-manifest": z.object({
+      createdAt: z.string(),
+      updatedAt: z.string(),
+      updatedBy: z.string(),
+      value: ServerManifest
+    }).optional()
+  })
+}), InternalStudioUserApplication = StudioUserApplicationBase.extend({
+  urlType: z.literal("internal"),
+  activeDeployment: ActiveDeployment.extend({
+    manifest: ServerManifest.nullable()
+  })
+}), ExternalStudioUserApplication = StudioUserApplicationBase.extend({
+  urlType: z.literal("external"),
+  activeDeployment: z.null()
+}), StudioUserApplication = z.discriminatedUnion("urlType", [
+  InternalStudioUserApplication,
+  ExternalStudioUserApplication
+]);
+function parseStudioUserApplication(data) {
+  return StudioUserApplication.parse(data);
+}
+const joinUrlPaths = (...paths) => {
+  let nextPath = null;
+  const safeJoinSegments = (segment1, segment2) => segment1 ? segment2 ? segment1.endsWith("/") && segment2.startsWith("/") ? segment1 + segment2.slice(1) : segment1.endsWith("/") || segment2.startsWith("/") ? segment1 + segment2 : `${segment1}/${segment2}` : segment1 : segment2 || "", validPaths = paths.filter(
+    (path) => path != null
+  );
+  for (const path of validPaths)
+    nextPath = safeJoinSegments(
+      nextPath,
+      path instanceof URL ? path.pathname : path
+    );
+  return nextPath ?? "";
+};
+function normalizePath(pathname) {
+  return pathname.startsWith("/") || (pathname = `/${pathname}`), pathname !== "/" && pathname.endsWith("/") && (pathname = pathname.slice(0, -1)), pathname;
+}
+class StudioWorkspace extends AbstractApplication {
+  /**
+   * Workspaces always belong to a studio application.
+   * They do not exist on their own & therefore can access
+   * information about the studio they're in via this property.
+   */
+  studioApplication;
+  workspace;
+  project;
+  isDefaultWorkspace;
+  constructor(studioApplication, workspace, project, isDefaultWorkspace) {
+    super("workspace"), this.studioApplication = studioApplication, this.workspace = workspace, this.project = project, this.isDefaultWorkspace = isDefaultWorkspace;
+  }
+  /**
+   * The studio application that this workspace belongs to.
+   */
+  get studio() {
+    return this.studioApplication;
+  }
+  get id() {
+    return StudioWorkspace.makeId(this.studio.id, this.workspace.name);
+  }
+  get href() {
+    return joinUrlPaths(this.studio.href, this.workspace.name);
+  }
+  get title() {
+    return this.isDefaultWorkspace ? this.project.displayName : this.workspace.title;
+  }
+  get subtitle() {
+    return this.isDefaultWorkspace ? (URL.canParse(this.studio.get("appHost")) ? new URL(this.studio.get("appHost")) : this.studio.url).hostname : this.get("subtitle");
+  }
+  get(attr) {
+    return this.workspace[attr];
+  }
+  /**
+   * With comlink, studio-applications were not considered applications at all, only workspaces. This is partially why
+   * we create default workspaces when the application has no manifest or the manifest has no workspaces.
+   *
+   * Thereby, to create it we depend on a lot of information from the parent application even if it's duplicated across
+   * different workspaces.
+   */
+  toProtocolResource() {
+    return {
+      ...this.workspace,
+      type: "studio",
+      userApplicationId: this.studio.id,
+      activeDeployment: this.studio.get("activeDeployment"),
+      autoUpdatingVersion: this.studio.get("autoUpdatingVersion"),
+      dashboardStatus: this.studio.get("dashboardStatus"),
+      url: this.studio.url.toString(),
+      href: this.href,
+      id: this.id,
+      hasManifest: !0,
+      hasSchema: !!("schema" in this.workspace && this.workspace.schema),
+      manifest: this.studio.get("manifestData")?.value ?? null,
+      updatedAt: this.studio.get("updatedAt"),
+      version: this.studio.get("activeDeployment")?.version,
+      urlType: this.studio.get("urlType"),
+      config: this.studio.get("config")
+    };
+  }
+  /**
+   * @returns the URL to the workspace of a studio application.
+   */
+  get url() {
+    const studioUrl = new URL(this.studio.url), normalizedUrlPath = normalizePath(studioUrl.pathname);
+    let finalBasePath = normalizePath(this.get("basePath"));
+    return finalBasePath.startsWith(normalizedUrlPath) && (finalBasePath = finalBasePath.slice(normalizedUrlPath.length)), studioUrl.pathname = joinUrlPaths(normalizedUrlPath, finalBasePath), studioUrl;
+  }
+  static makeId(applicationId, workspaceName) {
+    return `${applicationId}-${workspaceName}`;
+  }
+  static splitId(id) {
+    return id.split(new RegExp(/-(.*)/)).slice(0, 2);
+  }
+}
+const ClientManifest = ClientManifest$1.superRefine((data, ctx) => {
+  data.version || ctx.addIssue({
+    code: "invalid_type",
+    message: "Manifest version is too old",
+    expected: "number"
+  }), data.version < 2 && ctx.addIssue({
+    code: "invalid_value",
+    message: "Manifest version is too old",
+    values: [2, 3]
+  }), data.version >= 3 && !data.studioVersion && ctx.addIssue({
+    code: "invalid_type",
+    message: "Manifest version 3 or higher requires a `studioVersion`",
+    expected: "string"
+  });
+}), DEFAULT_WORKSPACE_DATA = {
+  name: "default",
+  title: "Default",
+  basePath: "/"
+};
+class StudioApplication extends UserApplication {
+  /**
+   * Returns a list of studio workspaces based on the application manifest.
+   * If there is no manifest, or alternatively it is not valid, then we create a default workspace.
+   */
+  workspaces = [];
+  project;
+  /**
+   * The projects actually referenced by this studio — the application's own
+   * project plus any project used by a workspace. Preserved so the instance
+   * can be re-constructed (e.g. by dock wrappers) without having to thread
+   * the full organization project list through again.
+   */
+  projects;
+  /**
+   * @param application - The studio application to create a list of workspaces for
+   * @param projects - The projects available in the organization. It's not enough to just pass
+   * the project that associates with the application because that is the project the app is deployed in relation to.
+   * The workspaces may have different projects completely.
+   */
+  constructor(application, projects) {
+    super(application, "studio");
+    let workspaces = [];
+    if (this.hasManifest)
+      try {
+        workspaces = ClientManifest.parse(
+          application.manifestData?.value
+        ).workspaces;
+      } catch (error) {
+        console.warn(
+          `Failed to parse manifest for application ${application.id}`,
+          error
+        );
+      }
+    if (workspaces.length === 0) {
+      const serverManifestWorkspaces = application.activeDeployment?.manifest?.workspaces;
+      Array.isArray(serverManifestWorkspaces) && serverManifestWorkspaces.length && (workspaces = serverManifestWorkspaces);
+    }
+    const workspacesWithProjectsMap = workspaces.reduce((acc, workspace) => {
+      const project2 = projects.find((p) => p.id === workspace.projectId);
+      return project2 ? acc.set(workspace, project2) : console.warn(
+        `Project not found for application ${application.id} and workspace ${workspace.name}. This workspace has been omitted.`
+      ), acc;
+    }, /* @__PURE__ */ new Map()), project = projects.find((p) => p.id === application.projectId);
+    if (!project)
+      throw new Error(`Project not found for application ${application.id}`);
+    workspacesWithProjectsMap.size === 0 && workspacesWithProjectsMap.set(
+      {
+        ...DEFAULT_WORKSPACE_DATA,
+        projectId: application.projectId
+      },
+      project
+    ), this.workspaces = Object.freeze(
+      Array.from(workspacesWithProjectsMap.entries()).map(([workspace, p]) => {
+        const isDefaultWorkspace = workspace.name === DEFAULT_WORKSPACE_DATA.name && workspace.basePath === DEFAULT_WORKSPACE_DATA.basePath && workspace.title === DEFAULT_WORKSPACE_DATA.title;
+        return new StudioWorkspace(this, workspace, p, isDefaultWorkspace);
+      })
+    ), this.project = project;
+    const usedProjects = /* @__PURE__ */ new Set([project]);
+    for (const workspace of this.workspaces)
+      usedProjects.add(workspace.project);
+    this.projects = Array.from(usedProjects);
+  }
+  get href() {
+    return `/studio/${this.application.id}`;
+  }
+  get title() {
+    return this.get("title") || (this.workspaces.length > 1 && this.get("urlType") === "internal" ? this.project.displayName : this.workspaces[0].title);
+  }
+  get subtitle() {
+    return new URL(this.url).hostname;
+  }
+  get(attr) {
+    if (!(attr in this.application))
+      throw new Error(
+        `Attribute ${attr.toString()} does not exist on studio ${this.application.id}`
+      );
+    return this.application[attr];
+  }
+  get hasManifest() {
+    return typeof this.application.manifestData?.value?.version == "number" && this.application.manifestData?.value?.version >= 2;
+  }
+  get hasSchema() {
+    const workspaces = this.get("manifestData")?.value?.workspaces ?? [];
+    return workspaces.length === 0 ? !1 : workspaces.every((w) => !!w.schema);
+  }
+  resolveVersion() {
+    let version;
+    if (this.get("urlType") === "internal")
+      version = this.get("activeDeployment")?.version;
+    else {
+      const manifest = this.get("manifestData")?.value;
+      version = manifest && "studioVersion" in manifest ? manifest.studioVersion : void 0;
+    }
+    const bundleVersion = this.get("activeDeployment")?.manifest?.bundleVersion;
+    return bundleVersion && valid(coerce(bundleVersion)) && (!version || version && gt(bundleVersion, version)) && (version = bundleVersion), !version || !valid(coerce(version)) ? null : coerce(version);
+  }
+  get version() {
+    const version = this.resolveVersion();
+    return version ? version.toString() : null;
+  }
+  get compatibilityStatus() {
+    return StudioApplication.resolveCompatibilityStatus(this);
+  }
+  /**
+   * Used to calculate the compatibility status of a given studio application.
+   * Optionally if you've resolved the version elsewhere provide that value to
+   * get the new compatibility status without mutating the application.
+   */
+  static resolveCompatibilityStatus(application, version = application.version) {
+    return version === null || lt(version, StudioApplication.MinimumStudioVersion) ? StudioApplication.CompatibilityStatuses.UNKNOWN : !application.hasSchema || !application.hasManifest || StudioApplication.resolveIssues(application, version).length > 0 ? StudioApplication.CompatibilityStatuses.PARTIALLY_COMPATIBLE : StudioApplication.CompatibilityStatuses.FULLY_COMPATIBLE;
+  }
+  get isAutoRedirecting() {
+    return StudioApplication.resolveIsAutoRedirecting(this);
+  }
+  /**
+   * Mirrors the `isRedirectable` function from Saison defined in
+   * https://github.com/sanity-io/saison/blob/83556405d23e07f6d3a71c76249c67e33fe1101f/src/utils/applications.ts
+   *
+   * Returns whether a studio application is auto-redirecting, meaning it can only be accessed in the context of
+   * Dashboard.
+   */
+  static resolveIsAutoRedirecting(application, versionArg = application.version) {
+    let version = versionArg;
+    if (application.get("urlType") === "external" || !version)
+      return !1;
+    if (!application.get("activeDeployment")?.isAutoUpdating)
+      return gt(version, "3.92.0");
+    const autoUpdatingVersion = application.get("autoUpdatingVersion");
+    if (autoUpdatingVersion) {
+      if (["next", "stable", "latest"].includes(autoUpdatingVersion))
+        return !0;
+      const autoUpdatingVersionPinnedVersion = coerce(autoUpdatingVersion);
+      autoUpdatingVersionPinnedVersion && (version = autoUpdatingVersionPinnedVersion);
+    }
+    return gt(version, StudioApplication.MinimumStudioVersion);
+  }
+  /**
+   * Returns a list of issues that prevent the studio from functioning properly in the Dashboard.
+   * This static value depends on the version of the studio that comes from the `activeDeployment` property.
+   * As such, if the studio is auto-updating, this list will be incorrect & instead you should use
+   * the static method `resolveIssues` to get the correct issues by passing the resolved version.
+   */
+  get issues() {
+    return StudioApplication.resolveIssues(this);
+  }
+  static resolveIssues(application, version = application.version) {
+    const issues = StudioApplication.Features.filter(
+      (feature) => !application.isFeatureSupported(feature.id, version)
+    );
+    return application.hasManifest || issues.push({
+      id: StudioApplication.StudioIssues.ISSUE_MANIFEST
+    }), issues;
+  }
+  isFeatureSupported(feature, version = this.version) {
+    const featureVersion = StudioApplication.Features.find(
+      (_) => _.id === feature
+    )?.version;
+    return !featureVersion || !version ? !1 : gte(version, featureVersion);
+  }
+  toProtocolResource() {
+    throw new Error(
+      "Studio application resources cannot be converted to protocol resources"
+    );
+  }
+  static CompatibilityStatuses = {
+    UNKNOWN: "unknown",
+    PARTIALLY_COMPATIBLE: "partially-compatible",
+    FULLY_COMPATIBLE: "fully-compatible"
+  };
+  static StudioIssues = {
+    ISSUE_ACTIVITY: "ACTIVITY",
+    ISSUE_AGENT: "AGENT",
+    ISSUE_FAVORITES: "FAVORITES",
+    ISSUE_URL_SYNCING: "URL_SYNCING",
+    ISSUE_UI_ADJUSTMENT: "UI_ADJUSTMENT",
+    ISSUE_CONTENT_MAPPING: "CONTENT_MAPPING",
+    ISSUE_LOGIN: "LOGIN",
+    ISSUE_MANIFEST: "MANIFEST"
+  };
+  static Features = [
+    {
+      id: StudioApplication.StudioIssues.ISSUE_AGENT,
+      version: "5.1.0"
+    },
+    {
+      id: StudioApplication.StudioIssues.ISSUE_FAVORITES,
+      version: "3.88.1"
+    },
+    {
+      id: StudioApplication.StudioIssues.ISSUE_ACTIVITY,
+      version: "3.88.1"
+    },
+    {
+      id: StudioApplication.StudioIssues.ISSUE_URL_SYNCING,
+      version: "3.75.0"
+    },
+    {
+      id: StudioApplication.StudioIssues.ISSUE_UI_ADJUSTMENT,
+      version: "3.78.1"
+    },
+    {
+      id: StudioApplication.StudioIssues.ISSUE_CONTENT_MAPPING,
+      version: "3.68.0"
+    },
+    {
+      id: StudioApplication.StudioIssues.ISSUE_LOGIN,
+      version: "2.28.0"
+    }
+  ];
+  static MinimumStudioVersion = "2.28.0";
+  static MinimumStudioVersionWithNoIssues = rsort(
+    StudioApplication.Features.map((feature) => feature.version)
+  ).at(0);
+}
+export {
+  AbstractApplication,
+  ActiveDeployment,
+  ApplicationList,
+  CanvasApplication,
+  ClientManifest$1 as ClientManifest,
+  CoreAppApplication,
+  LocalApplication,
+  MediaLibraryApplication,
+  Organization,
+  OrganizationId,
+  Project,
+  ProjectId,
+  StudioApplication,
+  StudioUserApplication,
+  StudioWorkspace,
+  UserApplication,
+  UserApplicationBase,
+  UserApplicationId,
+  brandCanvasId,
+  brandMediaLibraryId,
+  brandOrganizationId,
+  brandProjectId,
+  brandUserApplicationId,
+  createLogger,
+  logger,
+  parseCanvas,
+  parseCoreApplication,
+  parseMediaLibrary,
+  parseOrganization,
+  parseProject,
+  parseStudioUserApplication
+};
+//# sourceMappingURL=core.js.map