@superblocksteam/shared 0.9584.10 → 0.9585.0

package/src/types/user/index.ts

@@ -82,6 +82,28 @@ export enum UserType {
 
 export type UserAuthSource = 'Superblocks' | 'Auth0' | 'Anonymous';
 
+export enum JoinRequestStatus {
+  APPROVED = 'APPROVED',
+  CANCELLED = 'CANCELLED',
+  DENIED = 'DENIED',
+  PENDING = 'PENDING'
+}
+
+export interface JoinRequestDto {
+  id: string;
+  requesterEmail: string;
+  requesterName: string;
+  targetOrganizationId: string;
+  targetOrganizationName: string;
+  status: JoinRequestStatus;
+  created: Date;
+}
+
+export interface MatchingDomainOrgDto {
+  id: string;
+  name: string;
+}
+
 export enum RequestSource {
   SUPERBLOCKS = 'superblocks',
   EMBED = 'embed'

package/src/utils/attachment-delivery.ts

@@ -0,0 +1,96 @@
+import { getTextAttachmentType } from './attachment-upload.js';
+
+export type AttachmentDeliveryMode = 'inline_native' | 'reference_only';
+export type AttachmentArchiveType = 'gz' | 'tgz' | 'zip';
+
+const ARCHIVE_MIME_TYPES_BY_TYPE: Record<AttachmentArchiveType, Set<string>> = {
+  gz: new Set(['application/gzip', 'application/x-gzip']),
+  tgz: new Set([
+    'application/tar+gzip',
+    'application/x-compressed-tar',
+    'application/x-gtar',
+    'application/x-tar+gzip',
+    'application/x-tgz'
+  ]),
+  zip: new Set(['application/x-zip', 'application/x-zip-compressed', 'application/zip'])
+};
+
+type AttachmentTypeInput = {
+  fileName?: string;
+  mimeType?: string | null;
+};
+
+function normalizeMimeType(mimeType?: string | null): string {
+  return mimeType?.trim().toLowerCase() ?? '';
+}
+
+function normalizeFileName(fileName?: string): string {
+  return fileName?.trim().toLowerCase() ?? '';
+}
+
+function hasAnyFileName(input: AttachmentTypeInput): boolean {
+  return normalizeFileName(input.fileName).length > 0;
+}
+
+export function detectAttachmentArchiveType(input: AttachmentTypeInput): AttachmentArchiveType | null {
+  const fileName = normalizeFileName(input.fileName);
+  if (fileName.endsWith('.tar.gz') || fileName.endsWith('.tgz')) {
+    return 'tgz';
+  }
+  if (fileName.endsWith('.zip')) {
+    return 'zip';
+  }
+  if (fileName.endsWith('.gzip') || fileName.endsWith('.gz')) {
+    return 'gz';
+  }
+
+  const mimeType = normalizeMimeType(input.mimeType);
+  if (!mimeType) {
+    return null;
+  }
+
+  if (ARCHIVE_MIME_TYPES_BY_TYPE.zip.has(mimeType)) {
+    return 'zip';
+  }
+  if (ARCHIVE_MIME_TYPES_BY_TYPE.tgz.has(mimeType)) {
+    return 'tgz';
+  }
+  if (ARCHIVE_MIME_TYPES_BY_TYPE.gz.has(mimeType)) {
+    return 'gz';
+  }
+  return null;
+}
+
+export function classifyAttachmentDelivery(input: AttachmentTypeInput): AttachmentDeliveryMode {
+  if (detectAttachmentArchiveType(input)) {
+    return 'reference_only';
+  }
+
+  const mimeType = normalizeMimeType(input.mimeType);
+  if (mimeType.startsWith('image/') || mimeType === 'application/pdf') {
+    return 'inline_native';
+  }
+
+  if (
+    getTextAttachmentType({
+      fileName: input.fileName,
+      mimeType
+    }) !== null
+  ) {
+    return 'inline_native';
+  }
+
+  return 'reference_only';
+}
+
+export function isSupportedAttachmentUploadType(input: AttachmentTypeInput): boolean {
+  if (detectAttachmentArchiveType(input)) {
+    return true;
+  }
+
+  if (!hasAnyFileName(input) && !normalizeMimeType(input.mimeType)) {
+    return false;
+  }
+
+  return classifyAttachmentDelivery(input) === 'inline_native';
+}

package/src/utils/attachment-upload.ts

@@ -106,6 +106,12 @@ type UploadPdfAttachmentLike = {
   fileName: string;
 };
 
+type UploadArchiveAttachmentLike = {
+  type: 'archive';
+  data: string;
+  fileName: string;
+};
+
 type UploadTextAttachmentLike = {
   type: 'csv' | 'css' | 'json' | 'txt' | 'yaml';
   content: string;
@@ -121,6 +127,7 @@ export type AttachmentUploadSourceLike =
   | Blob
   | File
   | UploadAttachmentDataLike
+  | UploadArchiveAttachmentLike
   | UploadImageAttachmentLike
   | UploadPdfAttachmentLike
   | UploadTextAttachmentLike
@@ -449,9 +456,10 @@ export function toAttachmentUploadDescriptor(
     };
   }
 
-  if (source.type === 'pdf') {
+  if (source.type === 'pdf' || source.type === 'archive') {
     const parsedDataUrl = parseDataUrl(source.data);
-    const mimeType = parsedDataUrl?.mimeType ?? normalizeNonEmptyString(options?.fallbackMimeType) ?? 'application/pdf';
+    const defaultMimeType = source.type === 'pdf' ? 'application/pdf' : 'application/octet-stream';
+    const mimeType = parsedDataUrl?.mimeType ?? normalizeNonEmptyString(options?.fallbackMimeType) ?? defaultMimeType;
 
     return {
       blob: new Blob([decodeBase64(parsedDataUrl?.base64Data ?? source.data)], {

package/src/utils/index.ts

@@ -1,5 +1,6 @@
 export * from './configuration.js';
 export * from './attachment-upload.js';
+export * from './attachment-delivery.js';
 export * from './env.js';
 export * from './environment.js';
 export * from './git-url.js';