snapshot of https://github.com/toeverything/AFFiNE.git (canary, 2026-09-16; blobs > 131072B omitted)

packages/common/env/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@affine/env",
+  "private": true,
+  "type": "module",
+  "devDependencies": {
+    "vitest": "^4.1.8"
+  },
+  "exports": {
+    "./automation": "./src/automation.ts",
+    "./global": "./src/global.ts",
+    "./constant": "./src/constant.ts",
+    "./workspace": "./src/workspace.ts",
+    "./filter": "./src/filter.ts",
+    "./blocksuite": "./src/blocksuite/index.ts",
+    "./worker": "./src/worker.ts"
+  },
+  "peerDependencies": {
+    "@affine/templates": "workspace:*",
+    "@blocksuite/affine": "workspace:*"
+  },
+  "dependencies": {
+    "zod": "^3.25.76"
+  },
+  "version": "0.27.5"
+}

packages/common/env/src/__tests__/is-valid-ip-address.spec.ts

@@ -0,0 +1,27 @@
+import { describe, expect, test } from 'vitest';
+
+import { isValidIPAddress } from '../is-valid-ip-address.js';
+
+describe('isValidIpAddress', () => {
+  test('should return true for valid IP address', () => {
+    ['115.42.150.37', '192.168.0.1', '110.234.52.124', 'localhost'].forEach(
+      ip => {
+        expect(isValidIPAddress(ip)).toBe(true);
+      }
+    );
+  });
+
+  test('should return false for invalid IP address', () => {
+    [
+      '210.110',
+      '255',
+      'y.y.y.y',
+      '255.0.0.y',
+      '666.10.10.20',
+      '4444.11.11.11',
+      '33.3333.33.3',
+    ].forEach(ip => {
+      expect(isValidIPAddress(ip)).toBe(false);
+    });
+  });
+});

packages/common/env/src/automation.ts

@@ -0,0 +1,12 @@
+import type { z } from 'zod';
+
+export type Action<
+  InputSchema extends z.ZodObject<any, any, any, any>,
+  Args extends readonly any[],
+> = {
+  id: string;
+  name: string;
+  description: string;
+  inputSchema: InputSchema;
+  action: (input: z.input<InputSchema>, ...args: Args) => void;
+};

packages/common/env/src/constant.ts

@@ -0,0 +1,114 @@
+// This file should has not side effect
+
+declare global {
+  // oxlint-disable-next-line no-var
+  var __appInfo: {
+    electron: boolean;
+    scheme: string;
+    windowName: string;
+  };
+}
+
+export const DEFAULT_WORKSPACE_NAME = 'Demo Workspace';
+export const UNTITLED_WORKSPACE_NAME = 'Untitled';
+
+export const DEFAULT_SORT_KEY = 'updatedDate';
+export const MessageCode = {
+  loginError: 0,
+  noPermission: 1,
+  loadListFailed: 2,
+  getDetailFailed: 3,
+  createWorkspaceFailed: 4,
+  getMembersFailed: 5,
+  updateWorkspaceFailed: 6,
+  deleteWorkspaceFailed: 7,
+  inviteMemberFailed: 8,
+  removeMemberFailed: 9,
+  acceptInvitingFailed: 10,
+  getBlobFailed: 11,
+  leaveWorkspaceFailed: 12,
+  downloadWorkspaceFailed: 13,
+  refreshTokenError: 14,
+  blobTooLarge: 15,
+} as const;
+
+export const Messages = {
+  [MessageCode.loginError]: {
+    message: 'Login failed',
+  },
+  [MessageCode.noPermission]: {
+    message: 'No permission',
+  },
+  [MessageCode.loadListFailed]: {
+    message: 'Load list failed',
+  },
+  [MessageCode.getDetailFailed]: {
+    message: 'Get detail failed',
+  },
+  [MessageCode.createWorkspaceFailed]: {
+    message: 'Create workspace failed',
+  },
+  [MessageCode.getMembersFailed]: {
+    message: 'Get members failed',
+  },
+  [MessageCode.updateWorkspaceFailed]: {
+    message: 'Update workspace failed',
+  },
+  [MessageCode.deleteWorkspaceFailed]: {
+    message: 'Delete workspace failed',
+  },
+  [MessageCode.inviteMemberFailed]: {
+    message: 'Invite member failed',
+  },
+  [MessageCode.removeMemberFailed]: {
+    message: 'Remove member failed',
+  },
+  [MessageCode.acceptInvitingFailed]: {
+    message: 'Accept inviting failed',
+  },
+  [MessageCode.getBlobFailed]: {
+    message: 'Get blob failed',
+  },
+  [MessageCode.leaveWorkspaceFailed]: {
+    message: 'Leave workspace failed',
+  },
+  [MessageCode.downloadWorkspaceFailed]: {
+    message: 'Download workspace failed',
+  },
+  [MessageCode.refreshTokenError]: {
+    message: 'Refresh token failed',
+  },
+  [MessageCode.blobTooLarge]: {
+    message: 'Blob too large',
+  },
+} as const satisfies {
+  [key in (typeof MessageCode)[keyof typeof MessageCode]]: {
+    message: string;
+  };
+};
+
+export class WorkspaceNotFoundError extends TypeError {
+  readonly workspaceId: string;
+
+  constructor(workspaceId: string) {
+    super();
+    this.workspaceId = workspaceId;
+  }
+}
+
+export class QueryParamError extends TypeError {
+  readonly targetKey: string;
+  readonly query: unknown;
+
+  constructor(targetKey: string, query: unknown) {
+    super();
+    this.targetKey = targetKey;
+    this.query = query;
+  }
+}
+
+export class Unreachable extends Error {
+  constructor(message?: string) {
+    super(message);
+  }
+}

packages/common/env/src/filter.ts

@@ -0,0 +1,60 @@
+import type { DocsPropertiesMeta } from '@blocksuite/affine/store';
+import { z } from 'zod';
+
+export const literalValueSchema: z.ZodType<LiteralValue, z.ZodTypeDef> =
+  z.union([
+    z.number(),
+    z.string(),
+    z.boolean(),
+    z.array(z.lazy(() => literalValueSchema)),
+    z.record(z.lazy(() => literalValueSchema)),
+  ]);
+
+export type LiteralValue =
+  | number
+  | string
+  | boolean
+  | {
+      [K: string]: LiteralValue;
+    }
+  | Array<LiteralValue>;
+
+export const refSchema: z.ZodType<Ref, z.ZodTypeDef> = z.object({
+  type: z.literal('ref'),
+  name: z.never(),
+});
+
+export type Ref = {
+  type: 'ref';
+  name: keyof VariableMap;
+};
+
+export interface VariableMap {}
+
+export const literalSchema = z.object({
+  type: z.literal('literal'),
+  value: literalValueSchema,
+});
+
+export type Literal = z.input<typeof literalSchema>;
+
+export const filterSchema = z.object({
+  type: z.literal('filter'),
+  left: refSchema,
+  funcName: z.string(),
+  args: z.array(literalSchema),
+});
+
+export type Filter = z.input<typeof filterSchema>;
+
+export const collectionSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  filterList: z.array(filterSchema),
+  allowList: z.array(z.string()),
+  createDate: z.union([z.date(), z.number()]).optional(),
+  updateDate: z.union([z.date(), z.number()]).optional(),
+});
+export type Collection = z.input<typeof collectionSchema>;
+
+export type PropertiesMeta = DocsPropertiesMeta;

packages/common/env/src/global.ts

@@ -0,0 +1,83 @@
+import { UaHelper } from './ua-helper.js';
+
+export function setupGlobal() {
+  if (globalThis.$AFFINE_SETUP) {
+    return;
+  }
+
+  let environment: Environment = {
+    isLinux: false,
+    isMacOs: false,
+    isSafari: false,
+    isWindows: false,
+    isFireFox: false,
+    isChrome: false,
+    isIOS: false,
+    isPwa: false,
+    isMobile: false,
+    isSelfHosted: false,
+    // publicPath is the root of assets files
+    publicPath: '/',
+    // subPath is the path to access the affine service
+    subPath: '',
+  };
+
+  if (globalThis.navigator) {
+    const uaHelper = new UaHelper(globalThis.navigator);
+
+    environment = {
+      ...environment,
+      isMobile: uaHelper.isMobile,
+      isLinux: uaHelper.isLinux,
+      isMacOs: uaHelper.isMacOs,
+      isSafari: uaHelper.isSafari,
+      isWindows: uaHelper.isWindows,
+      isFireFox: uaHelper.isFireFox,
+      isChrome: uaHelper.isChrome,
+      isIOS: uaHelper.isIOS,
+      isPwa: uaHelper.isStandalone,
+    };
+    // Chrome on iOS is still Safari
+    if (environment.isChrome && !environment.isIOS) {
+      environment = {
+        ...environment,
+        isSafari: false,
+        isFireFox: false,
+        isChrome: true,
+        chromeVersion: uaHelper.getChromeVersion(),
+      };
+    }
+  }
+
+  applyEnvironmentOverrides(environment);
+
+  globalThis.environment = environment;
+  globalThis.$AFFINE_SETUP = true;
+}
+
+function applyEnvironmentOverrides(environment: Environment) {
+  if (typeof document === 'undefined') {
+    return;
+  }
+
+  const metaTags = document.querySelectorAll('meta');
+
+  metaTags.forEach(meta => {
+    if (!meta.name.startsWith('env:')) {
+      return;
+    }
+
+    const name = meta.name.substring(4);
+
+    // all environments should have default value
+    // so ignore non-defined overrides
+    if (name in environment) {
+      // @ts-expect-error safe
+      environment[name] =
+        // @ts-expect-error safe
+        typeof environment[name] === 'string'
+          ? meta.content
+          : JSON.parse(meta.content);
+    }
+  });
+}

packages/common/env/src/is-valid-ip-address.ts

@@ -0,0 +1,8 @@
+export function isValidIPAddress(address: string) {
+  if (address === 'localhost') {
+    return true;
+  }
+  return /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/.test(
+    address
+  );
+}

packages/common/env/src/page-info.ts

@@ -0,0 +1,7 @@
+export type PageInfo = {
+  isEdgeless: boolean;
+  title: string;
+  id: string;
+};
+
+export type GetPageInfoById = (id: string) => PageInfo | undefined;

packages/common/env/src/ua-helper.ts

@@ -0,0 +1,94 @@
+export class UaHelper {
+  private readonly uaMap;
+  public isLinux = false;
+  public isMacOs = false;
+  public isSafari = false;
+  public isWindows = false;
+  public isFireFox = false;
+  public isMobile = false;
+  public isChrome = false;
+  public isIOS = false;
+  public isStandalone = false;
+
+  getChromeVersion = (): number => {
+    let raw = this.navigator.userAgent.match(/Chrom(e|ium)\/([0-9]+)\./);
+    if (!raw) {
+      raw = this.navigator.userAgent.match(/(CriOS)\/([0-9]+)/);
+    }
+    if (!raw) {
+      console.error('Cannot get chrome version');
+      return 0;
+    }
+    return parseInt(raw[2] ?? '', 10);
+  };
+
+  constructor(private readonly navigator: Navigator) {
+    this.uaMap = getUa(navigator);
+    this.initUaFlags();
+  }
+
+  public checkUseragent(isUseragent: keyof ReturnType<typeof getUa>) {
+    return Boolean(this.uaMap[isUseragent]);
+  }
+
+  private isStandaloneMode() {
+    if (typeof window === 'undefined') {
+      return false;
+    }
+    if ('standalone' in window.navigator) {
+      return !!window.navigator.standalone;
+    }
+    return !!window.matchMedia('(display-mode: standalone)').matches;
+  }
+
+  private initUaFlags() {
+    this.isLinux = this.checkUseragent('linux');
+    this.isMacOs = this.checkUseragent('mac');
+    this.isSafari = this.checkUseragent('safari');
+    this.isWindows = this.checkUseragent('win');
+    this.isFireFox = this.checkUseragent('firefox');
+    this.isMobile = this.checkUseragent('mobile');
+    this.isChrome = this.checkUseragent('chrome');
+    this.isIOS = this.checkUseragent('ios');
+    this.isStandalone = this.isStandaloneMode();
+  }
+}
+
+const getUa = (navigator: Navigator) => {
+  const ua = navigator.userAgent;
+  const uas = ua.toLowerCase();
+  const mobile = /iPhone|iPad|iPod|Android/i.test(ua);
+  const android =
+    (mobile && (uas.indexOf('android') > -1 || uas.indexOf('linux') > -1)) ||
+    uas.indexOf('adr') > -1;
+  const ios = mobile && !android && /Mac OS/i.test(ua);
+  const mac = !mobile && /Mac OS/i.test(ua);
+  const iphone = ios && uas.indexOf('iphone') > -1;
+  const ipad = ios && !iphone;
+  const wx = /MicroMessenger/i.test(ua);
+  const chrome = /CriOS/i.test(ua) || /Chrome/i.test(ua);
+  const tiktok = mobile && /aweme/i.test(ua);
+  const weibo = mobile && /Weibo/i.test(ua);
+  const safari =
+    !chrome && !wx && !weibo && !tiktok && /Safari|Macintosh/i.test(ua);
+  const firefox = /Firefox/.test(ua);
+  const win = /windows|win32|win64|wow32|wow64/.test(uas);
+  const linux = /linux/.test(uas);
+  return {
+    ua,
+    mobile,
+    android,
+    ios,
+    mac,
+    wx,
+    chrome,
+    iphone,
+    ipad,
+    safari,
+    tiktok,
+    weibo,
+    win,
+    linux,
+    firefox,
+  };
+};

packages/common/env/src/worker.ts

@@ -0,0 +1,8 @@
+export function getWorkerUrl(name: string) {
+  return (
+    // NOTE: worker can not use publicPath because it must obey the same-origin policy
+    (environment.subPath || '/') +
+    'js/' +
+    `${name}-${BUILD_CONFIG.appVersion}.worker.js`
+  );
+}

packages/common/env/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../../tsconfig.web.json",
+  "compilerOptions": {
+    "types": ["build-config", "affine__env"],
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "tsBuildInfoFile": "./dist/tsconfig.tsbuildinfo"
+  },
+  "include": ["./src"],
+  "references": []
+}