@rynt/sdk 0.9.53

package/src/extensions/registries/get-registry.ts

@@ -0,0 +1,23 @@
+import type { ExtensionRegistryPayloadMap } from '@rynt/sdk/extension-registry-payload-map';
+import type {
+  BuiltinRegistryValueMap,
+  KnownBuiltinRegistryId,
+} from './registry-value-map';
+import {
+  createExtensionRegistryApi,
+  type ExtensionRegistryApi,
+} from './extension-registry-api';
+
+/** @deprecated Используйте {@link ExtensionRegistryApi} / {@link getExtensionRegistry}. */
+export type ExtensionRegistryHandle<T> = ExtensionRegistryApi<T>;
+
+export function getRegistry<I extends KnownBuiltinRegistryId>(
+  registryId: I,
+): ExtensionRegistryApi<BuiltinRegistryValueMap[I]>;
+export function getRegistry<K extends keyof ExtensionRegistryPayloadMap>(
+  registryId: K,
+): ExtensionRegistryApi<ExtensionRegistryPayloadMap[K]>;
+export function getRegistry<T>(registryId: string): ExtensionRegistryApi<T>;
+export function getRegistry<T>(registryId: string): ExtensionRegistryApi<T> {
+  return createExtensionRegistryApi<T>(registryId);
+}

package/src/extensions/registries/index.ts

@@ -0,0 +1,58 @@
+export {
+  clearRegistryBucket,
+  deleteRegistryItem,
+  extensionRegistriesRevision,
+  getRegistryEntryMeta,
+  getRegistryItem,
+  hasRegistryItem,
+  listRegistryEntries,
+  listRegistryKeys,
+  listRegistryValuesSorted,
+  resetExtensionRegistries,
+  setRegistryItem,
+  unregisterRegistryEntriesForExtension,
+  type RegistryEntry,
+  type RegistryEntryMeta,
+} from './store';
+export {
+  getCurrentExtensionId,
+  HOST_EXTENSION_ID,
+  popExtensionScope,
+  pushExtensionScope,
+  withExtensionScope,
+} from './extension-scope';
+export { ensureCoreExtensionRegistries } from './bootstrap';
+export { getRegistry, type ExtensionRegistryHandle } from './get-registry';
+export {
+  defineExtensionRegistry,
+  getExtensionRegistry,
+  type ExtensionRegistryApi,
+  type RegistryRow,
+  type UseExtensionRegistry,
+} from './define-extension-registry';
+export type { ExtensionRegistryPayloadMap } from '@rynt/sdk/extension-registry-payload-map';
+export type {
+  BuiltinRegistryId,
+  BuiltinRegistryValueMap,
+  KnownBuiltinRegistryId,
+} from './registry-value-map';
+export {
+  applyValidatedRyntContributesToManifest,
+  flattenExtendsRegistries,
+  getRyntContributesFromManifest,
+  KNOWN_CORE_REGISTRY_IDS,
+  validateRyntManifestContributes,
+  type ParsedRyntManifestContributes,
+  type RegistryDeclaration,
+  type RegistryExtensionContribution,
+  type RegistrySlotRef,
+} from './manifest-rynt';
+export {
+  getRegistryEntryRow,
+  hasRegistryEntry,
+  resolveRegistrySlot,
+  type RegistrySlotResolveResult,
+} from './registry-slot';
+export { clearExtensionUiRegistries } from './clear-extension-ui-registries';
+
+export * from './builtins';

package/src/extensions/registries/manifest-rynt.ts

@@ -0,0 +1,193 @@
+import { z } from 'zod';
+
+const registryDeclSchema = z.object({
+  id: z.string().min(1),
+  title: z.string().optional(),
+  description: z.string().optional(),
+});
+
+const registryExtendSchema = z.object({
+  registryId: z.string().min(1),
+  keys: z.array(z.string().min(1)).min(1),
+});
+
+const ryntContributesSchema = z
+  .object({
+    declaresRegistries: z.array(registryDeclSchema).optional(),
+    extendsRegistries: z.array(registryExtendSchema).optional(),
+  })
+  .strict();
+
+export type RegistryDeclaration = z.infer<typeof registryDeclSchema>;
+export type RegistryExtensionContribution = z.infer<typeof registryExtendSchema>;
+
+export type ParsedRyntManifestContributes = z.infer<typeof ryntContributesSchema>;
+
+export interface RegistrySlotRef {
+  registryId: string;
+  key: string;
+}
+
+/** Встроенные реестры ядра — implied dependency на владельца не требуется. */
+export const KNOWN_CORE_REGISTRY_IDS = new Set<string>([
+  'core.page',
+  'core.nav',
+  'core.sidebar',
+  'core.shell',
+  'core.userStrip',
+  'core.loader',
+  'core.accountProvider',
+  'core.inviteHandler',
+  'core.modProvider',
+  'core.modManageActions',
+  'core.resourcepackManageActions',
+  'core.shaderpackManageActions',
+  'core.fileEditor',
+  'core.theme',
+  'core.sidebarBeforeContent',
+  'core.sidebarAfterContent',
+  'core.markdownEditorToolbarActions',
+  'core.markdownEditorTiptapExtensions',
+  'core.markdownRendererBeforeContent',
+  'core.markdownRendererAfterContent',
+  'core.buildDetailBeforeContent',
+  'core.buildDetailAfterContent',
+  'core.buildDetailHeaderActions',
+  'core.modDetailsFooterActions',
+  'core.mapDetailBeforeContent',
+  'core.mapDetailAfterContent',
+  'core.mapDetailHeaderActions',
+  'core.serverDetailBeforeContent',
+  'core.serverDetailAfterContent',
+  'core.serverDetailHeaderActions',
+  'core.buildCardActions',
+  'core.mapCardActions',
+  'core.serverCardActions',
+  'core.appTopbarLeftWidgets',
+  'core.appTopbarRightWidgets',
+  'core.appTopbarStatusWidgets',
+  'core.sidebarHeaderWidgets',
+  'core.sidebarFooterWidgets',
+  'core.userMenuActions',
+  'core.userMenuBeforeActions',
+  'core.userMenuAfterActions',
+  'core.feedBeforeContent',
+  'core.feedAfterContent',
+  'core.libraryBeforeContent',
+  'core.libraryAfterContent',
+  'core.friendsBeforeList',
+  'core.friendsAfterList',
+  'core.projectsBeforeContent',
+  'core.projectsAfterContent',
+  'core.settingsBeforeSections',
+  'core.settingsAfterSections',
+  'core.settingsSectionWidgets',
+  'core.buildCardBeforeMedia',
+  'core.buildCardBeforeMeta',
+  'core.buildCardAfterMeta',
+  'core.buildCardFooterActions',
+  'core.mapCardBeforeMeta',
+  'core.mapCardAfterMeta',
+  'core.mapCardFooterActions',
+  'core.serverCardBeforeMeta',
+  'core.serverCardAfterMeta',
+  'core.serverCardFooterActions',
+  'core.userCardBeforeMeta',
+  'core.userCardAfterMeta',
+  'core.buildDetailBeforeHero',
+  'core.buildDetailRightColumnTop',
+  'core.buildDetailRightColumnBottom',
+  'core.buildDetailModRowActions',
+  'core.buildDetailResourcepackRowActions',
+  'core.dialogFooterActions',
+]);
+
+export function flattenExtendsRegistries(
+  contributes: ParsedRyntManifestContributes | undefined,
+): RegistrySlotRef[] {
+  if (!contributes?.extendsRegistries?.length) {
+    return [];
+  }
+  const out: RegistrySlotRef[] = [];
+  for (const block of contributes.extendsRegistries) {
+    for (const key of block.keys) {
+      out.push({ registryId: block.registryId, key });
+    }
+  }
+  return out;
+}
+
+export function getRyntContributesFromManifest(manifest: {
+  contributes?: Record<string, unknown>;
+}): ParsedRyntManifestContributes | undefined {
+  const raw = manifest.contributes?.rynt;
+  if (!raw || typeof raw !== 'object') {
+    return undefined;
+  }
+  return raw as ParsedRyntManifestContributes;
+}
+
+export function validateRyntManifestContributes(
+  extensionId: string,
+  raw: unknown,
+): { ok: true; data: ParsedRyntManifestContributes } | { ok: false; error: string } {
+  if (raw === undefined) {
+    return { ok: true, data: {} };
+  }
+  const parsed = ryntContributesSchema.safeParse(raw);
+  if (!parsed.success) {
+    const msg = parsed.error.issues
+      .map((i) => `${i.path.join('.')}: ${i.message}`)
+      .join('; ');
+    return { ok: false, error: msg };
+  }
+  const data = parsed.data;
+
+  const declared = data.declaresRegistries;
+  if (declared?.length) {
+    const ids = declared.map((d) => d.id);
+    const uniq = new Set(ids);
+    if (uniq.size !== ids.length) {
+      return { ok: false, error: 'declaresRegistries: дублирующиеся id' };
+    }
+  }
+
+  const extended = data.extendsRegistries;
+  if (extended?.length) {
+    const registryIds = extended.map((e) => e.registryId);
+    const uniqReg = new Set(registryIds);
+    if (uniqReg.size !== registryIds.length) {
+      return { ok: false, error: 'extendsRegistries: дублирующийся registryId' };
+    }
+    for (const block of extended) {
+      const uniqKeys = new Set(block.keys);
+      if (uniqKeys.size !== block.keys.length) {
+        return {
+          ok: false,
+          error: `extendsRegistries[${block.registryId}]: дублирующиеся keys`,
+        };
+      }
+    }
+  }
+
+  return { ok: true, data };
+}
+
+export function applyValidatedRyntContributesToManifest(manifest: {
+  id: string;
+  contributes?: Record<string, unknown>;
+}): string | null {
+  const raw = manifest.contributes?.rynt;
+  if (raw === undefined) {
+    return null;
+  }
+  const v = validateRyntManifestContributes(manifest.id, raw);
+  if (!v.ok) {
+    return v.error;
+  }
+  manifest.contributes = {
+    ...(manifest.contributes ?? {}),
+    rynt: v.data,
+  };
+  return null;
+}

package/src/extensions/registries/registry-slot.ts

@@ -0,0 +1,40 @@
+import type { RegistryRow } from './extension-registry-api';
+import {
+  getRegistryEntryMeta,
+  hasRegistryItem,
+} from './store';
+
+export type RegistrySlotResolveResult<T = unknown> =
+  | { status: 'present'; row: RegistryRow<T> }
+  | { status: 'missing' };
+
+export function hasRegistryEntry(registryId: string, key: string): boolean {
+  return hasRegistryItem(registryId, key);
+}
+
+export function getRegistryEntryRow<T = unknown>(
+  registryId: string,
+  key: string,
+): RegistryRow<T> | undefined {
+  const meta = getRegistryEntryMeta<T>(registryId, key);
+  if (!meta) {
+    return undefined;
+  }
+  return {
+    registryKey: key,
+    extensionId: meta.extensionId,
+    order: meta.order,
+    value: meta.value,
+  };
+}
+
+export function resolveRegistrySlot<T = unknown>(
+  registryId: string,
+  key: string,
+): RegistrySlotResolveResult<T> {
+  const row = getRegistryEntryRow<T>(registryId, key);
+  if (!row) {
+    return { status: 'missing' };
+  }
+  return { status: 'present', row };
+}

package/src/extensions/registries/registry-value-map.ts

@@ -0,0 +1,89 @@
+import type { Component } from 'vue';
+
+import type { BaseLoader } from '../../minecraft-loader/base-loader';
+import type { ThemeDefinition } from '../../shared/themes/types';
+import type { NavigationSection } from '../../shared/types/navigation';
+import type { ModMarketplaceProvider } from '../../shared/mods/mod-marketplace-types';
+import type { FileEditorProvider } from './builtins/file-editor';
+import type { IAuthProvider } from '../launcher-models/apis/accounts-contracts';
+import type { InviteHandlerRegistration } from '../invite-handler/types';
+import type { CoreNavItem, CorePageItem, CoreSidebarItem } from './builtins';
+
+/**
+ * Встроенные реестры: ключ = строковый id из `registries/builtins/*`.
+ */
+export interface BuiltinRegistryValueMap {
+  'core.page': CorePageItem;
+  'core.nav': CoreNavItem;
+  'core.sidebar': CoreSidebarItem;
+  'core.userStrip': Component;
+  'core.shell': Component;
+  'core.loader': BaseLoader;
+  'core.accountProvider': IAuthProvider;
+  'core.inviteHandler': InviteHandlerRegistration;
+  'core.modProvider': ModMarketplaceProvider;
+  'core.modManageActions': Component;
+  'core.resourcepackManageActions': Component;
+  'core.shaderpackManageActions': Component;
+  'core.fileEditor': FileEditorProvider;
+  'core.sidebarBeforeContent': Component;
+  'core.sidebarAfterContent': Component;
+  'core.markdownEditorToolbarActions': Component;
+  'core.markdownEditorTiptapExtensions': import('@tiptap/core').AnyExtension;
+  'core.markdownRendererBeforeContent': Component;
+  'core.markdownRendererAfterContent': Component;
+  'core.buildDetailBeforeContent': Component;
+  'core.buildDetailAfterContent': Component;
+  'core.buildDetailHeaderActions': Component;
+  'core.modDetailsFooterActions': Component;
+  'core.mapDetailBeforeContent': Component;
+  'core.mapDetailAfterContent': Component;
+  'core.mapDetailHeaderActions': Component;
+  'core.serverDetailBeforeContent': Component;
+  'core.serverDetailAfterContent': Component;
+  'core.serverDetailHeaderActions': Component;
+  'core.buildCardActions': Component;
+  'core.mapCardActions': Component;
+  'core.serverCardActions': Component;
+  'core.appTopbarLeftWidgets': Component;
+  'core.appTopbarRightWidgets': Component;
+  'core.appTopbarStatusWidgets': Component;
+  'core.sidebarHeaderWidgets': Component;
+  'core.sidebarFooterWidgets': Component;
+  'core.userMenuActions': Component;
+  'core.userMenuBeforeActions': Component;
+  'core.userMenuAfterActions': Component;
+  'core.feedBeforeContent': Component;
+  'core.feedAfterContent': Component;
+  'core.libraryBeforeContent': Component;
+  'core.libraryAfterContent': Component;
+  'core.friendsBeforeList': Component;
+  'core.friendsAfterList': Component;
+  'core.projectsBeforeContent': Component;
+  'core.projectsAfterContent': Component;
+  'core.settingsBeforeSections': Component;
+  'core.settingsAfterSections': Component;
+  'core.settingsSectionWidgets': Component;
+  'core.buildCardBeforeMedia': Component;
+  'core.buildCardBeforeMeta': Component;
+  'core.buildCardAfterMeta': Component;
+  'core.buildCardFooterActions': Component;
+  'core.mapCardBeforeMeta': Component;
+  'core.mapCardAfterMeta': Component;
+  'core.mapCardFooterActions': Component;
+  'core.serverCardBeforeMeta': Component;
+  'core.serverCardAfterMeta': Component;
+  'core.serverCardFooterActions': Component;
+  'core.userCardBeforeMeta': Component;
+  'core.userCardAfterMeta': Component;
+  'core.buildDetailBeforeHero': Component;
+  'core.buildDetailRightColumnTop': Component;
+  'core.buildDetailRightColumnBottom': Component;
+  'core.buildDetailModRowActions': Component;
+  'core.buildDetailResourcepackRowActions': Component;
+  'core.dialogFooterActions': Component;
+}
+
+export type KnownBuiltinRegistryId = keyof BuiltinRegistryValueMap;
+
+export type BuiltinRegistryId = KnownBuiltinRegistryId;

package/src/extensions/registries/store.ts

@@ -0,0 +1,206 @@
+import { reactive, shallowRef } from 'vue';
+
+import { HOST_EXTENSION_ID } from './extension-scope';
+import type {
+  BuiltinRegistryValueMap,
+  KnownBuiltinRegistryId,
+} from './registry-value-map';
+
+export interface RegistryEntryMeta {
+  /** Источник записи: id расширения или {@link HOST_EXTENSION_ID} для лаунчера. */
+  extensionId: string;
+  order?: number;
+}
+
+export interface RegistryEntry<T = unknown> extends RegistryEntryMeta {
+  value: T;
+}
+
+/** Реактивные вложенные `Map`: в `computed`/`watch` достаточно читать через публичные API без `revision`. */
+const buckets = reactive(new Map<string, Map<string, RegistryEntry>>());
+
+const declaredRegistryIds = new Set<string>();
+
+/** Ревизия любого изменения любого реестра (для Vue). */
+export const extensionRegistriesRevision = shallowRef(0);
+
+function bumpRevision(): void {
+  extensionRegistriesRevision.value += 1;
+}
+
+function ensureBucket(registryId: string): Map<string, RegistryEntry> {
+  let m = buckets.get(registryId);
+  if (!m) {
+    m = reactive(new Map<string, RegistryEntry>());
+    buckets.set(registryId, m);
+  }
+  return m;
+}
+
+/**
+ * Идемпотентно помечает реестр как объявленный ядром / автором (`defineExtensionRegistry`)
+ * и создаёт bucket. Для динамических id без объявления — {@link touchExtensionRegistryBucket}.
+ */
+export function declareExtensionRegistryId(registryId: string): void {
+  if (
+    declaredRegistryIds.has(registryId) &&
+    process.env.NODE_ENV === 'development'
+  ) {
+    console.warn(
+      `[rynt/registries] declareExtensionRegistryId: id «${registryId}» уже объявлен`,
+    );
+  }
+  declaredRegistryIds.add(registryId);
+  ensureBucket(registryId);
+}
+
+/** Гарантирует наличие bucket (динамический `registryId`, `getExtensionRegistry`). */
+export function touchExtensionRegistryBucket(registryId: string): void {
+  ensureBucket(registryId);
+}
+
+/**
+ * Базовая запись в реестр с явно указанным `extensionId`.
+ * Применяется внутри `ExtensionRegistryApi.register(...)` (берёт id из scope), `ctx.registerRegistryEntry`,
+ * и обёрток-классов вроде `LoaderRegistry`.
+ */
+export function setRegistryItem<I extends KnownBuiltinRegistryId>(
+  registryId: I,
+  key: string,
+  value: BuiltinRegistryValueMap[I],
+  extensionId: string,
+  order?: number,
+): void;
+export function setRegistryItem<T>(
+  registryId: string,
+  key: string,
+  value: T,
+  extensionId: string,
+  order?: number,
+): void;
+export function setRegistryItem<T>(
+  registryId: string,
+  key: string,
+  value: T,
+  extensionId: string,
+  order?: number,
+): void {
+  const map = ensureBucket(registryId);
+  map.set(key, { value, extensionId, order });
+  bumpRevision();
+}
+
+export function getRegistryItem<I extends KnownBuiltinRegistryId>(
+  registryId: I,
+  key: string,
+): BuiltinRegistryValueMap[I] | undefined;
+export function getRegistryItem<T>(
+  registryId: string,
+  key: string,
+): T | undefined;
+export function getRegistryItem<T>(
+  registryId: string,
+  key: string,
+): T | undefined {
+  return buckets.get(registryId)?.get(key)?.value as T | undefined;
+}
+
+export function hasRegistryItem(registryId: string, key: string): boolean {
+  return buckets.get(registryId)?.has(key) ?? false;
+}
+
+export function listRegistryKeys(registryId: string): string[] {
+  return [...(buckets.get(registryId)?.keys() ?? [])];
+}
+
+export function listRegistryEntries<I extends KnownBuiltinRegistryId>(
+  registryId: I,
+): [string, BuiltinRegistryValueMap[I]][];
+export function listRegistryEntries<T>(registryId: string): [string, T][];
+export function listRegistryEntries<T>(registryId: string): [string, T][] {
+  const m = buckets.get(registryId);
+  if (!m) return [];
+  return [...m.entries()].map(([k, e]) => [k, e.value as T]);
+}
+
+/** Значения в порядке `order` (по возрастанию), затем по ключу. */
+export function listRegistryValuesSorted<I extends KnownBuiltinRegistryId>(
+  registryId: I,
+): BuiltinRegistryValueMap[I][];
+export function listRegistryValuesSorted<T>(registryId: string): T[];
+export function listRegistryValuesSorted<T>(registryId: string): T[] {
+  const m = buckets.get(registryId);
+  if (!m) return [];
+  const rows = [...m.entries()].map(([key, e]) => ({
+    key,
+    order: e.order ?? 100,
+    value: e.value as T,
+  }));
+  rows.sort((a, b) => a.order - b.order || a.key.localeCompare(b.key));
+  return rows.map((r) => r.value);
+}
+
+export function deleteRegistryItem(registryId: string, key: string): boolean {
+  const m = buckets.get(registryId);
+  if (!m?.delete(key)) {
+    return false;
+  }
+  bumpRevision();
+  return true;
+}
+
+export function clearRegistryBucket(registryId: string): void {
+  const m = buckets.get(registryId);
+  if (!m || m.size === 0) {
+    return;
+  }
+  m.clear();
+  bumpRevision();
+}
+
+export function getRegistryEntryMeta<I extends KnownBuiltinRegistryId>(
+  registryId: I,
+  key: string,
+): RegistryEntry<BuiltinRegistryValueMap[I]> | undefined;
+export function getRegistryEntryMeta<T>(
+  registryId: string,
+  key: string,
+): RegistryEntry<T> | undefined;
+export function getRegistryEntryMeta(
+  registryId: string,
+  key: string,
+): RegistryEntry | undefined {
+  return buckets.get(registryId)?.get(key);
+}
+
+/** Удалить все записи, принадлежащие расширению (хост-записи под {@link HOST_EXTENSION_ID} не трогаются). */
+export function unregisterRegistryEntriesForExtension(
+  extensionId: string,
+): void {
+  if (extensionId === HOST_EXTENSION_ID) {
+    console.warn(
+      '[rynt/registries] unregisterRegistryEntriesForExtension: host extensionId is reserved, skipping',
+    );
+    return;
+  }
+  let changed = false;
+  for (const [, map] of buckets.entries()) {
+    for (const [k, entry] of [...map.entries()]) {
+      if (entry.extensionId === extensionId) {
+        map.delete(k);
+        changed = true;
+      }
+    }
+  }
+  if (changed) {
+    bumpRevision();
+  }
+}
+
+/** Полный сброс содержимого всех реестров (перед повторной загрузкой расширений). */
+export function resetExtensionRegistries(): void {
+  for (const map of buckets.values()) {
+    map.clear();
+  }
+  bumpRevision();
+}