@workbench-kit/workbench-config 0.0.2-prototype.0.2.4 → 0.0.2-prototype.0.2.40

package/package.json

@@ -1,15 +1,11 @@
 {
   "name": "@workbench-kit/workbench-config",
-  "version": "0.0.2-prototype.0.2.4",
+  "version": "0.0.2-prototype.0.2.40",
   "private": false,
   "type": "module",
   "exports": {
     ".": "./src/index.ts"
   },
-  "dependencies": {
-    "@workbench-kit/base": "0.0.2-prototype.0.2.4",
-    "@workbench-kit/platform": "0.0.2-prototype.0.2.4"
-  },
   "files": [
     "src",
     "!src/**/*.test.ts",

package/src/index.ts

@@ -1,7 +1,6 @@
+import { assertKnownKeys, assertRecord, parseConfigJson } from './parse-helpers.js';
 import { WorkbenchConfigValidationError } from './validation-error.js';
 
-export const WORKBENCH_KIT_WORKBENCH_CONFIG_VERSION = '0.0.0' as const;
-
 export const WORKBENCH_CONFIG_DIR = '.workbench' as const;
 
 export type WorkbenchConfigFileName =
@@ -19,6 +18,16 @@ export interface WorkbenchExtensionsConfig {
   recommendations: readonly string[];
 }
 
+export interface WorkbenchExtensionsLockEntry {
+  readonly integrity?: string | undefined;
+  readonly version: string;
+}
+
+export interface WorkbenchExtensionsLock {
+  readonly extensions: Readonly<Record<string, WorkbenchExtensionsLockEntry>>;
+  readonly lockfileVersion: number;
+}
+
 export interface WorkbenchLayoutConfig {
   readonly activityBar: {
     readonly hiddenItemIds?: readonly string[];
@@ -29,6 +38,8 @@ export interface WorkbenchLayoutConfig {
     readonly visible: boolean;
   };
   readonly panel: {
+    readonly activeViewContainer?: string;
+    readonly sizePercent?: number;
     readonly visible: boolean;
   };
   readonly sideBar: {
@@ -72,15 +83,50 @@ export function parseWorkbenchExtensionsConfig(input: unknown): WorkbenchExtensi
 }
 
 export function parseWorkbenchExtensionsConfigJson(jsonText: string): WorkbenchExtensionsConfig {
-  try {
-    return parseWorkbenchExtensionsConfig(JSON.parse(jsonText) as unknown);
-  } catch (error) {
-    if (error instanceof WorkbenchConfigValidationError) {
-      throw error;
-    }
+  return parseConfigJson(jsonText, parseWorkbenchExtensionsConfig, 'extensions config');
+}
 
-    throw new WorkbenchConfigValidationError('Expected extensions config to be valid JSON.');
+export function parseWorkbenchExtensionsLock(input: unknown): WorkbenchExtensionsLock {
+  const record = assertRecord(input, 'extensions lock');
+  const lockfileVersion = record.lockfileVersion;
+  if (
+    typeof lockfileVersion !== 'number' ||
+    !Number.isInteger(lockfileVersion) ||
+    lockfileVersion < 1
+  ) {
+    throw new WorkbenchConfigValidationError(
+      'Expected extensions lock "lockfileVersion" to be a positive integer.',
+    );
   }
+
+  const extensionsRecord = assertRecord(record.extensions ?? {}, 'extensions lock extensions');
+  const extensions: Record<string, WorkbenchExtensionsLockEntry> = {};
+  for (const [extensionId, rawEntry] of Object.entries(extensionsRecord)) {
+    const entry = assertRecord(rawEntry, `extensions lock entry "${extensionId}"`);
+    if (typeof entry.version !== 'string' || entry.version.trim().length === 0) {
+      throw new WorkbenchConfigValidationError(
+        `Expected extensions lock entry "${extensionId}" to include a non-empty version.`,
+      );
+    }
+    if (entry.integrity !== undefined && typeof entry.integrity !== 'string') {
+      throw new WorkbenchConfigValidationError(
+        `Expected extensions lock entry "${extensionId}" integrity to be a string.`,
+      );
+    }
+    extensions[extensionId] = {
+      integrity: typeof entry.integrity === 'string' ? entry.integrity : undefined,
+      version: entry.version.trim(),
+    };
+  }
+
+  return {
+    extensions,
+    lockfileVersion,
+  };
+}
+
+export function parseWorkbenchExtensionsLockJson(jsonText: string): WorkbenchExtensionsLock {
+  return parseConfigJson(jsonText, parseWorkbenchExtensionsLock, 'extensions lock');
 }
 
 export function parseWorkbenchLayoutConfig(input: unknown): WorkbenchLayoutConfig {
@@ -98,7 +144,7 @@ export function parseWorkbenchLayoutConfig(input: unknown): WorkbenchLayoutConfi
     'layout config activityBar',
   );
   assertKnownKeys(auxiliaryBar, ['visible'], 'layout config auxiliaryBar');
-  assertKnownKeys(panel, ['visible'], 'layout config panel');
+  assertKnownKeys(panel, ['activeViewContainer', 'sizePercent', 'visible'], 'layout config panel');
   assertKnownKeys(
     sideBar,
     ['activeViewContainer', 'sizePercent', 'visible'],
@@ -123,6 +169,8 @@ export function parseWorkbenchLayoutConfig(input: unknown): WorkbenchLayoutConfi
       ),
     },
     panel: {
+      ...readOptionalLayoutId(panel, 'activeViewContainer'),
+      ...readOptionalSizePercent(panel, 'sizePercent'),
       visible: readOptionalBoolean(panel, 'visible', DEFAULT_WORKBENCH_LAYOUT_CONFIG.panel.visible),
     },
     sideBar: {
@@ -138,15 +186,7 @@ export function parseWorkbenchLayoutConfig(input: unknown): WorkbenchLayoutConfi
 }
 
 export function parseWorkbenchLayoutConfigJson(jsonText: string): WorkbenchLayoutConfig {
-  try {
-    return parseWorkbenchLayoutConfig(JSON.parse(jsonText) as unknown);
-  } catch (error) {
-    if (error instanceof WorkbenchConfigValidationError) {
-      throw error;
-    }
-
-    throw new WorkbenchConfigValidationError('Expected layout config to be valid JSON.');
-  }
+  return parseConfigJson(jsonText, parseWorkbenchLayoutConfig, 'layout config');
 }
 
 export {
@@ -161,12 +201,10 @@ export {
 } from './settings-config.js';
 export {
   createEmptyPreferenceValuesByScope,
-  FUTURE_PREFERENCE_SCOPES,
   isPreferenceScope,
   mergePreferenceValuesByScope,
   mergeScopedPreferences,
   PREFERENCE_SCOPE_MERGE_ORDER,
-  type FuturePreferenceScope,
   type PreferenceScope,
   type PreferenceValuesByScope,
   type ScopedPreferenceLayer,
@@ -181,14 +219,6 @@ export {
   type WorkbenchUserCommandsConfig,
 } from './user-commands-config.js';
 
-function assertRecord(value: unknown, label: string): Record<string, unknown> {
-  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
-    throw new WorkbenchConfigValidationError(`Expected ${label} to be an object.`);
-  }
-
-  return value as Record<string, unknown>;
-}
-
 function readOptionalRecord(record: Record<string, unknown>, key: string): Record<string, unknown> {
   const value = record[key];
   if (value === undefined) {
@@ -290,11 +320,3 @@ function readOptionalSizePercent(
 function clampLayoutSizePercent(value: number): number {
   return Math.min(90, Math.max(10, value));
 }
-
-function assertKnownKeys(record: Record<string, unknown>, keys: readonly string[], label: string) {
-  const knownKeys = new Set(keys);
-  const unknownKeys = Object.keys(record).filter((key) => !knownKeys.has(key));
-  if (unknownKeys.length > 0) {
-    throw new WorkbenchConfigValidationError(`Unexpected ${label} field "${unknownKeys[0]}".`);
-  }
-}

package/src/keybindings-config.ts

@@ -1,3 +1,10 @@
+import {
+  assertKnownKeys,
+  assertRecord,
+  parseConfigJson,
+  readOptionalString,
+  readRequiredString,
+} from './parse-helpers.js';
 import { WorkbenchConfigValidationError } from './validation-error.js';
 
 export interface WorkbenchKeybindingDefinition {
@@ -20,15 +27,7 @@ export function parseWorkbenchKeybindingsConfig(
 export function parseWorkbenchKeybindingsConfigJson(
   jsonText: string,
 ): readonly WorkbenchKeybindingDefinition[] {
-  try {
-    return parseWorkbenchKeybindingsConfig(JSON.parse(jsonText) as unknown);
-  } catch (error) {
-    if (error instanceof WorkbenchConfigValidationError) {
-      throw error;
-    }
-
-    throw new WorkbenchConfigValidationError('Expected keybindings config to be valid JSON.');
-  }
+  return parseConfigJson(jsonText, parseWorkbenchKeybindingsConfig, 'keybindings config');
 }
 
 function parseWorkbenchKeybindingDefinition(
@@ -48,36 +47,6 @@ function parseWorkbenchKeybindingDefinition(
   };
 }
 
-function assertRecord(value: unknown, label: string): Record<string, unknown> {
-  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
-    throw new WorkbenchConfigValidationError(`Expected ${label} to be an object.`);
-  }
-
-  return value as Record<string, unknown>;
-}
-
-function readRequiredString(record: Record<string, unknown>, key: string): string {
-  const value = record[key];
-  if (typeof value !== 'string' || value.trim().length === 0) {
-    throw new WorkbenchConfigValidationError(`Expected "${key}" to be a non-empty string.`);
-  }
-
-  return value.trim();
-}
-
-function readOptionalString(record: Record<string, unknown>, key: string): string | undefined {
-  const value = record[key];
-  if (value === undefined) {
-    return undefined;
-  }
-
-  if (typeof value !== 'string' || value.trim().length === 0) {
-    throw new WorkbenchConfigValidationError(`Expected "${key}" to be a non-empty string.`);
-  }
-
-  return value.trim();
-}
-
 function readOptionalArgs(record: Record<string, unknown>): readonly unknown[] | undefined {
   const value = record.args;
   if (value === undefined) {
@@ -90,11 +59,3 @@ function readOptionalArgs(record: Record<string, unknown>): readonly unknown[] |
 
   return [...value];
 }
-
-function assertKnownKeys(record: Record<string, unknown>, keys: readonly string[], label: string) {
-  const knownKeys = new Set(keys);
-  const unknownKeys = Object.keys(record).filter((key) => !knownKeys.has(key));
-  if (unknownKeys.length > 0) {
-    throw new WorkbenchConfigValidationError(`Unexpected ${label} field "${unknownKeys[0]}".`);
-  }
-}

package/src/parse-helpers.ts

@@ -0,0 +1,61 @@
+import { WorkbenchConfigValidationError } from './validation-error.js';
+
+export function assertRecord(value: unknown, label: string): Record<string, unknown> {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    throw new WorkbenchConfigValidationError(`Expected ${label} to be an object.`);
+  }
+
+  return value as Record<string, unknown>;
+}
+
+export function parseConfigJson<T>(
+  jsonText: string,
+  parseConfig: (input: unknown) => T,
+  configLabel: string,
+): T {
+  try {
+    return parseConfig(JSON.parse(jsonText) as unknown);
+  } catch (error) {
+    if (error instanceof WorkbenchConfigValidationError) {
+      throw error;
+    }
+    throw new WorkbenchConfigValidationError(`Expected ${configLabel} to be valid JSON.`);
+  }
+}
+
+export function readRequiredString(record: Record<string, unknown>, key: string): string {
+  const value = record[key];
+  if (typeof value !== 'string' || value.trim().length === 0) {
+    throw new WorkbenchConfigValidationError(`Expected "${key}" to be a non-empty string.`);
+  }
+
+  return value.trim();
+}
+
+export function readOptionalString(
+  record: Record<string, unknown>,
+  key: string,
+): string | undefined {
+  const value = record[key];
+  if (value === undefined) {
+    return undefined;
+  }
+
+  if (typeof value !== 'string' || value.trim().length === 0) {
+    throw new WorkbenchConfigValidationError(`Expected "${key}" to be a non-empty string.`);
+  }
+
+  return value.trim();
+}
+
+export function assertKnownKeys(
+  record: Record<string, unknown>,
+  keys: readonly string[],
+  label: string,
+) {
+  const knownKeys = new Set(keys);
+  const unknownKeys = Object.keys(record).filter((key) => !knownKeys.has(key));
+  if (unknownKeys.length > 0) {
+    throw new WorkbenchConfigValidationError(`Unexpected ${label} field "${unknownKeys[0]}".`);
+  }
+}

package/src/preference-scopes.ts

@@ -3,11 +3,6 @@ import type { WorkbenchSettingsConfig } from './settings-config.js';
 /** Runtime preference scopes supported in v1. */
 export type PreferenceScope = 'default' | 'workspace' | 'local';
 
-/** Documented future scopes — not merged or persisted yet. */
-export const FUTURE_PREFERENCE_SCOPES = ['user', 'resource', 'secret'] as const;
-
-export type FuturePreferenceScope = (typeof FUTURE_PREFERENCE_SCOPES)[number];
-
 /** Lower index = lower precedence when merging effective values. */
 export const PREFERENCE_SCOPE_MERGE_ORDER: readonly PreferenceScope[] = [
   'default',

package/src/settings-config.ts

@@ -1,3 +1,4 @@
+import { parseConfigJson } from './parse-helpers.js';
 import { WorkbenchConfigValidationError } from './validation-error.js';
 
 export type WorkbenchSettingsConfig = Readonly<Record<string, unknown>>;
@@ -7,17 +8,23 @@ export function parseWorkbenchSettingsConfig(input: unknown): WorkbenchSettingsC
     throw new WorkbenchConfigValidationError('Expected settings config to be an object.');
   }
 
-  return { ...(input as Record<string, unknown>) };
+  const settings = { ...(input as Record<string, unknown>) };
+  const colorTheme = settings['workbench.colorTheme'];
+  if (colorTheme !== undefined && typeof colorTheme !== 'string') {
+    throw new WorkbenchConfigValidationError('Expected workbench.colorTheme to be a string.');
+  }
+
+  const editorFontSize = settings['editor.fontSize'];
+  if (
+    editorFontSize !== undefined &&
+    (typeof editorFontSize !== 'number' || !Number.isFinite(editorFontSize) || editorFontSize < 1)
+  ) {
+    throw new WorkbenchConfigValidationError('Expected editor.fontSize to be a number >= 1.');
+  }
+
+  return settings;
 }
 
 export function parseWorkbenchSettingsConfigJson(jsonText: string): WorkbenchSettingsConfig {
-  try {
-    return parseWorkbenchSettingsConfig(JSON.parse(jsonText) as unknown);
-  } catch (error) {
-    if (error instanceof WorkbenchConfigValidationError) {
-      throw error;
-    }
-
-    throw new WorkbenchConfigValidationError('Expected settings config to be valid JSON.');
-  }
+  return parseConfigJson(jsonText, parseWorkbenchSettingsConfig, 'settings config');
 }

package/src/user-commands-config.ts

@@ -1,3 +1,10 @@
+import {
+  assertKnownKeys,
+  assertRecord,
+  parseConfigJson,
+  readOptionalString,
+  readRequiredString,
+} from './parse-helpers.js';
 import { WorkbenchConfigValidationError } from './validation-error.js';
 
 export interface WorkbenchUserCommandExecuteAction {
@@ -46,15 +53,7 @@ export function parseWorkbenchUserCommandsConfig(input: unknown): WorkbenchUserC
 export function parseWorkbenchUserCommandsConfigJson(
   jsonText: string,
 ): WorkbenchUserCommandsConfig {
-  try {
-    return parseWorkbenchUserCommandsConfig(JSON.parse(jsonText) as unknown);
-  } catch (error) {
-    if (error instanceof WorkbenchConfigValidationError) {
-      throw error;
-    }
-
-    throw new WorkbenchConfigValidationError('Expected user commands config to be valid JSON.');
-  }
+  return parseConfigJson(jsonText, parseWorkbenchUserCommandsConfig, 'user commands config');
 }
 
 function parseUserCommandDefinition(input: unknown, index: number): WorkbenchUserCommandDefinition {
@@ -102,36 +101,6 @@ function parseUserCommandAction(input: unknown, label: string): WorkbenchUserCom
   throw new WorkbenchConfigValidationError(`Unexpected ${label} type "${type}".`);
 }
 
-function assertRecord(value: unknown, label: string): Record<string, unknown> {
-  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
-    throw new WorkbenchConfigValidationError(`Expected ${label} to be an object.`);
-  }
-
-  return value as Record<string, unknown>;
-}
-
-function readRequiredString(record: Record<string, unknown>, key: string): string {
-  const value = record[key];
-  if (typeof value !== 'string' || value.trim().length === 0) {
-    throw new WorkbenchConfigValidationError(`Expected "${key}" to be a non-empty string.`);
-  }
-
-  return value.trim();
-}
-
-function readOptionalString(record: Record<string, unknown>, key: string): string | undefined {
-  const value = record[key];
-  if (value === undefined) {
-    return undefined;
-  }
-
-  if (typeof value !== 'string' || value.trim().length === 0) {
-    throw new WorkbenchConfigValidationError(`Expected "${key}" to be a non-empty string.`);
-  }
-
-  return value.trim();
-}
-
 function readOptionalNumber(record: Record<string, unknown>, key: string): number | undefined {
   const value = record[key];
   if (value === undefined) {
@@ -144,11 +113,3 @@ function readOptionalNumber(record: Record<string, unknown>, key: string): numbe
 
   return value;
 }
-
-function assertKnownKeys(record: Record<string, unknown>, keys: readonly string[], label: string) {
-  const knownKeys = new Set(keys);
-  const unknownKeys = Object.keys(record).filter((key) => !knownKeys.has(key));
-  if (unknownKeys.length > 0) {
-    throw new WorkbenchConfigValidationError(`Unexpected ${label} field "${unknownKeys[0]}".`);
-  }
-}