@lucifer.chao.du/home-schema-components 0.1.0

package/README.md

@@ -0,0 +1,9 @@
+# @packages/home-schema-components
+
+Shared home schema package for:
+
+- `@packages/home-schema-components/schema`
+- `@packages/home-schema-components/web-preview`
+
+Current release surface excludes the member runtime entry. The `member` source
+directory remains repo-internal and is not part of the published npm contract.

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@lucifer.chao.du/home-schema-components",
+  "version": "0.1.0",
+  "description": "Shared home schema components for member and web preview consumers.",
+  "license": "UNLICENSED",
+  "type": "module",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "files": [
+    "src/schema",
+    "src/web-preview",
+    "README.md"
+  ],
+  "peerDependencies": {
+    "vue": "^3.5.0"
+  },
+  "exports": {
+    "./schema": {
+      "types": "./src/schema/index.d.ts",
+      "import": "./src/schema/index.js"
+    },
+    "./web-preview": {
+      "types": "./src/web-preview/index.ts",
+      "import": "./src/web-preview/index.ts"
+    }
+  }
+}

package/src/schema/index.d.ts

@@ -0,0 +1,183 @@
+export type HomeSchemaComponent =
+  | 'activities'
+  | 'communities'
+  | 'services'
+  | 'tags'
+  | 'tools';
+
+export type JumpPath = {
+  audienceRule: any;
+  displayTitle: string;
+  jumpType: string;
+  placementId?: string;
+  resourceId?: string;
+  resourceType?: string;
+  sortOrder: number;
+  target?: string;
+  targetParams?: Record<string, string>;
+};
+
+export type ToolItem = {
+  icon: string;
+  path: JumpPath;
+  title: string;
+};
+
+export type CommunityItem = {
+  path: JumpPath;
+  title: string;
+};
+
+export type TagItem = {
+  icon: string;
+  path: JumpPath;
+  title: string;
+};
+
+export type ActivityItem = {
+  image: string;
+  path: JumpPath;
+};
+
+export type DiscountItem = {
+  discounted: number;
+  price: number;
+  project: string;
+  type: string;
+};
+
+export type ServiceItem = {
+  category: string;
+  count: string;
+  discount: DiscountItem[];
+  distance: string;
+  image: string;
+  path: JumpPath;
+  range: string;
+  rate: string;
+  title: string;
+  type: string;
+};
+
+export type ToolsMode = {
+  displayMultipleItems: number;
+  displayRowCount: number;
+};
+
+export type TagsMode = {
+  displayRowCount: number;
+  showIcon: boolean;
+};
+
+export type CommunitiesMode = {
+  autoplay: boolean;
+  displayMultipleItems: number;
+  duration: number;
+  interval: number;
+  showIcon: boolean;
+};
+
+export type ActivitiesMode = {
+  autoplay: boolean;
+  duration: number;
+  interval: number;
+};
+
+export type ServicesMode = Record<string, any>;
+
+export type NormalizedComponentPropsMap = {
+  activities: {
+    description?: string;
+    image: string;
+    mode: ActivitiesMode;
+    options: ActivityItem[];
+    title?: string;
+  };
+  communities: {
+    description?: string;
+    image: string;
+    mode: CommunitiesMode;
+    options: CommunityItem[];
+    title?: string;
+  };
+  services: {
+    description?: string;
+    image: string;
+    mode: ServicesMode;
+    options: ServiceItem[];
+    title?: string;
+  };
+  tags: {
+    description?: string;
+    image: string;
+    mode: TagsMode;
+    options: TagItem[];
+    title?: string;
+  };
+  tools: {
+    description?: string;
+    image: string;
+    mode: ToolsMode;
+    options: ToolItem[];
+    title?: string;
+  };
+};
+
+export type NormalizedComponentProps<T extends HomeSchemaComponent> =
+  NormalizedComponentPropsMap[T];
+
+export declare const HOME_SCHEMA_COMPONENTS: HomeSchemaComponent[];
+export declare function isPlainRecord(
+  value: unknown,
+): value is Record<string, any>;
+export declare function normalizeString(
+  value: unknown,
+  fallback?: string,
+): string;
+export declare function normalizeOptionalString(
+  value: unknown,
+): string | undefined;
+export declare function normalizeBoolean(
+  value: unknown,
+  fallback?: boolean,
+): boolean;
+export declare function normalizeNumber(
+  value: unknown,
+  fallback?: number,
+  limits?: { max?: number; min?: number },
+): number;
+export declare function createJumpPath(): JumpPath;
+export declare function normalizeJumpPath(value: unknown): JumpPath;
+export declare function createToolItem(): ToolItem;
+export declare function createCommunityItem(): CommunityItem;
+export declare function createTagItem(): TagItem;
+export declare function createActivityItem(): ActivityItem;
+export declare function createDiscountItem(): DiscountItem;
+export declare function createServiceItem(): ServiceItem;
+export declare function normalizeToolItem(value: unknown): ToolItem;
+export declare function normalizeCommunityItem(value: unknown): CommunityItem;
+export declare function normalizeTagItem(value: unknown): TagItem;
+export declare function normalizeActivityItem(value: unknown): ActivityItem;
+export declare function normalizeDiscountItem(value: unknown): DiscountItem;
+export declare function normalizeServiceItem(value: unknown): ServiceItem;
+export declare function normalizeOptions<T extends HomeSchemaComponent>(
+  componentType: T,
+  options: unknown,
+): NormalizedComponentPropsMap[T]['options'];
+export declare function normalizeToolsMode(mode: unknown): ToolsMode;
+export declare function normalizeTagsMode(mode: unknown): TagsMode;
+export declare function normalizeCommunitiesMode(mode: unknown): CommunitiesMode;
+export declare function normalizeActivitiesMode(mode: unknown): ActivitiesMode;
+export declare function normalizeServicesMode(mode: unknown): ServicesMode;
+export declare function normalizeMode<T extends HomeSchemaComponent>(
+  componentType: T,
+  mode: unknown,
+): NormalizedComponentPropsMap[T]['mode'];
+export declare function normalizeComponentProps<T extends HomeSchemaComponent>(
+  componentType: T,
+  componentProps: unknown,
+): NormalizedComponentPropsMap[T];
+export declare function getComponentOptionLabel(
+  componentType: HomeSchemaComponent,
+): string;
+export declare function getTextInitial(text: unknown, fallback?: string): string;

package/src/schema/index.js

@@ -0,0 +1,413 @@
+export const HOME_SCHEMA_COMPONENTS = [
+  'tools',
+  'communities',
+  'tags',
+  'activities',
+  'services',
+];
+
+const DEFAULT_LIMITS = {
+  activitiesDuration: { max: 3000, min: 100 },
+  communitiesDisplayMultipleItems: { max: 20, min: 1 },
+  interval: { max: 60000, min: 500 },
+  tagsDisplayRowCount: { max: 10, min: 1 },
+  toolsDisplayMultipleItems: { max: 50, min: 1 },
+  toolsDisplayRowCount: { max: 5, min: 3 },
+};
+
+export function isPlainRecord(value) {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+export function normalizeString(value, fallback = '') {
+  if (value === undefined || value === null) {
+    return fallback;
+  }
+  return String(value);
+}
+
+export function normalizeOptionalString(value) {
+  if (value === undefined || value === null || value === '') {
+    return undefined;
+  }
+  const normalized = String(value).trim();
+  return normalized || undefined;
+}
+
+export function normalizeBoolean(value, fallback = false) {
+  if (typeof value === 'boolean') {
+    return value;
+  }
+  if (typeof value === 'number') {
+    return value !== 0;
+  }
+  if (typeof value === 'string') {
+    const normalized = value.trim().toLowerCase();
+    if (['1', 'on', 'true', 'yes'].includes(normalized)) {
+      return true;
+    }
+    if (['0', 'off', 'false', 'no'].includes(normalized)) {
+      return false;
+    }
+  }
+  return fallback;
+}
+
+export function normalizeNumber(value, fallback = 0, limits = undefined) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) {
+    return fallback;
+  }
+
+  let normalized = Math.round(parsed);
+  if (Number.isFinite(limits?.min)) {
+    normalized = Math.max(normalized, Number(limits.min));
+  }
+  if (Number.isFinite(limits?.max)) {
+    normalized = Math.min(normalized, Number(limits.max));
+  }
+  return normalized;
+}
+
+function cloneValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => cloneValue(item));
+  }
+  if (isPlainRecord(value)) {
+    const payload = {};
+    Object.entries(value).forEach(([key, itemValue]) => {
+      payload[key] = cloneValue(itemValue);
+    });
+    return payload;
+  }
+  return value;
+}
+
+function normalizeKeyValueObject(value) {
+  if (value === undefined || value === null || value === '') {
+    return undefined;
+  }
+
+  if (typeof value === 'string') {
+    try {
+      return normalizeKeyValueObject(JSON.parse(value));
+    } catch {
+      return undefined;
+    }
+  }
+
+  if (!isPlainRecord(value)) {
+    return undefined;
+  }
+
+  const payload = {};
+  Object.entries(value).forEach(([key, itemValue]) => {
+    const normalizedKey = String(key || '').trim();
+    if (!normalizedKey) {
+      return;
+    }
+    payload[normalizedKey] =
+      itemValue === undefined || itemValue === null ? '' : String(itemValue);
+  });
+  return Object.keys(payload).length > 0 ? payload : undefined;
+}
+
+export function createJumpPath() {
+  return {
+    audienceRule: null,
+    displayTitle: '',
+    jumpType: 'NONE',
+    placementId: undefined,
+    resourceId: undefined,
+    resourceType: undefined,
+    sortOrder: 0,
+    target: undefined,
+    targetParams: undefined,
+  };
+}
+
+export function normalizeJumpPath(value) {
+  const rawPath = isPlainRecord(value) ? value : {};
+  const legacyTarget =
+    typeof value === 'string' ? normalizeOptionalString(value) : undefined;
+  const path = {
+    ...createJumpPath(),
+    ...cloneValue(rawPath),
+    displayTitle: normalizeString(rawPath.displayTitle),
+    jumpType:
+      normalizeString(rawPath.jumpType, legacyTarget ? 'H5_URL' : 'NONE') ||
+      'NONE',
+    placementId: normalizeOptionalString(rawPath.placementId),
+    resourceId: normalizeOptionalString(rawPath.resourceId),
+    resourceType: normalizeOptionalString(rawPath.resourceType),
+    sortOrder: normalizeNumber(rawPath.sortOrder, 0),
+    target: normalizeOptionalString(rawPath.target) ?? legacyTarget,
+    targetParams: normalizeKeyValueObject(rawPath.targetParams),
+  };
+
+  if (path.jumpType === 'NONE') {
+    path.target = undefined;
+    path.targetParams = undefined;
+  }
+
+  return path;
+}
+
+export function createToolItem() {
+  return {
+    icon: '',
+    path: createJumpPath(),
+    title: '',
+  };
+}
+
+export function createCommunityItem() {
+  return {
+    path: createJumpPath(),
+    title: '',
+  };
+}
+
+export function createTagItem() {
+  return {
+    icon: '',
+    path: createJumpPath(),
+    title: '',
+  };
+}
+
+export function createActivityItem() {
+  return {
+    image: '',
+    path: createJumpPath(),
+  };
+}
+
+export function createDiscountItem() {
+  return {
+    discounted: 0,
+    price: 0,
+    project: '',
+    type: 'discount',
+  };
+}
+
+export function createServiceItem() {
+  return {
+    category: '',
+    count: '',
+    discount: [createDiscountItem()],
+    distance: '',
+    image: '',
+    path: createJumpPath(),
+    range: '',
+    rate: '',
+    title: '',
+    type: 'home',
+  };
+}
+
+export function normalizeToolItem(value) {
+  const source = isPlainRecord(value) ? value : {};
+  return {
+    ...createToolItem(),
+    ...cloneValue(source),
+    icon: normalizeString(source.icon),
+    path: normalizeJumpPath(source.path),
+    title: normalizeString(source.title),
+  };
+}
+
+export function normalizeCommunityItem(value) {
+  const source = isPlainRecord(value) ? value : {};
+  return {
+    ...createCommunityItem(),
+    ...cloneValue(source),
+    path: normalizeJumpPath(source.path),
+    title: normalizeString(source.title),
+  };
+}
+
+export function normalizeTagItem(value) {
+  const source = isPlainRecord(value) ? value : {};
+  return {
+    ...createTagItem(),
+    ...cloneValue(source),
+    icon: normalizeString(source.icon),
+    path: normalizeJumpPath(source.path),
+    title: normalizeString(source.title),
+  };
+}
+
+export function normalizeActivityItem(value) {
+  const source = isPlainRecord(value) ? value : {};
+  return {
+    ...createActivityItem(),
+    ...cloneValue(source),
+    image: normalizeString(source.image),
+    path: normalizeJumpPath(source.path),
+  };
+}
+
+export function normalizeDiscountItem(value) {
+  const source = isPlainRecord(value) ? value : {};
+  return {
+    ...createDiscountItem(),
+    ...cloneValue(source),
+    discounted: normalizeNumber(source.discounted, 0),
+    price: normalizeNumber(source.price, 0),
+    project: normalizeString(source.project),
+    type: normalizeString(source.type, 'discount') || 'discount',
+  };
+}
+
+export function normalizeServiceItem(value) {
+  const source = isPlainRecord(value) ? value : {};
+  const discount = Array.isArray(source.discount)
+    ? source.discount.map((item) => normalizeDiscountItem(item))
+    : [];
+
+  return {
+    ...createServiceItem(),
+    ...cloneValue(source),
+    category: normalizeString(source.category),
+    count: normalizeString(source.count),
+    discount,
+    distance: normalizeString(source.distance),
+    image: normalizeString(source.image),
+    path: normalizeJumpPath(source.path),
+    range: normalizeString(source.range),
+    rate: normalizeString(source.rate),
+    title: normalizeString(source.title),
+    type: normalizeString(source.type, 'home') || 'home',
+  };
+}
+
+export function normalizeOptions(componentType, options) {
+  const source = Array.isArray(options) ? options : [];
+
+  switch (componentType) {
+    case 'activities':
+      return source.map((item) => normalizeActivityItem(item));
+    case 'communities':
+      return source.map((item) => normalizeCommunityItem(item));
+    case 'services':
+      return source.map((item) => normalizeServiceItem(item));
+    case 'tags':
+      return source.map((item) => normalizeTagItem(item));
+    case 'tools':
+    default:
+      return source.map((item) => normalizeToolItem(item));
+  }
+}
+
+export function normalizeToolsMode(mode) {
+  return {
+    displayMultipleItems: normalizeNumber(
+      mode?.displayMultipleItems,
+      10,
+      DEFAULT_LIMITS.toolsDisplayMultipleItems,
+    ),
+    displayRowCount: normalizeNumber(
+      mode?.displayRowCount,
+      5,
+      DEFAULT_LIMITS.toolsDisplayRowCount,
+    ),
+  };
+}
+
+export function normalizeTagsMode(mode) {
+  return {
+    displayRowCount: normalizeNumber(
+      mode?.displayRowCount,
+      4,
+      DEFAULT_LIMITS.tagsDisplayRowCount,
+    ),
+    showIcon: normalizeBoolean(mode?.showIcon, true),
+  };
+}
+
+export function normalizeCommunitiesMode(mode) {
+  return {
+    autoplay: normalizeBoolean(mode?.autoplay, true),
+    displayMultipleItems: normalizeNumber(
+      mode?.displayMultipleItems,
+      2,
+      DEFAULT_LIMITS.communitiesDisplayMultipleItems,
+    ),
+    duration: normalizeNumber(
+      mode?.duration,
+      500,
+      DEFAULT_LIMITS.activitiesDuration,
+    ),
+    interval: normalizeNumber(mode?.interval, 5000, DEFAULT_LIMITS.interval),
+    showIcon: normalizeBoolean(mode?.showIcon, true),
+  };
+}
+
+export function normalizeActivitiesMode(mode) {
+  return {
+    autoplay: normalizeBoolean(mode?.autoplay, true),
+    duration: normalizeNumber(
+      mode?.duration,
+      500,
+      DEFAULT_LIMITS.activitiesDuration,
+    ),
+    interval: normalizeNumber(mode?.interval, 5000, DEFAULT_LIMITS.interval),
+  };
+}
+
+export function normalizeServicesMode(mode) {
+  return isPlainRecord(mode) ? cloneValue(mode) : {};
+}
+
+export function normalizeMode(componentType, mode) {
+  switch (componentType) {
+    case 'activities':
+      return normalizeActivitiesMode(mode);
+    case 'communities':
+      return normalizeCommunitiesMode(mode);
+    case 'services':
+      return normalizeServicesMode(mode);
+    case 'tags':
+      return normalizeTagsMode(mode);
+    case 'tools':
+    default:
+      return normalizeToolsMode(mode);
+  }
+}
+
+export function normalizeComponentProps(componentType, componentProps) {
+  const source = isPlainRecord(componentProps) ? cloneValue(componentProps) : {};
+  return {
+    ...source,
+    description: normalizeOptionalString(source.description),
+    image: normalizeOptionalString(source.image) ?? '',
+    mode: normalizeMode(componentType, source.mode),
+    options: normalizeOptions(componentType, source.options),
+    title: normalizeOptionalString(source.title),
+  };
+}
+
+export function getComponentOptionLabel(componentType) {
+  switch (componentType) {
+    case 'activities':
+      return '横幅';
+    case 'communities':
+      return '播报';
+    case 'services':
+      return '服务';
+    case 'tags':
+      return '标签';
+    case 'tools':
+    default:
+      return '工具';
+  }
+}
+
+export function getTextInitial(text, fallback = 'L') {
+  return String(text || fallback)
+    .trim()
+    .slice(0, 1)
+    .toUpperCase();
+}