fss-link 1.0.49 → 1.0.51

package/dist/utils/settingsUtils.ts

@@ -1,489 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { Settings, SettingScope, LoadedSettings } from '../config/settings.js';
-import {
-  SETTINGS_SCHEMA,
-  SettingDefinition,
-  SettingsSchema,
-} from '../config/settingsSchema.js';
-
-// The schema is now nested, but many parts of the UI and logic work better
-// with a flattened structure and dot-notation keys. This section flattens the
-// schema into a map for easier lookups.
-
-function flattenSchema(
-  schema: SettingsSchema,
-  prefix = '',
-): Record<string, SettingDefinition & { key: string }> {
-  let result: Record<string, SettingDefinition & { key: string }> = {};
-  for (const key in schema) {
-    const newKey = prefix ? `${prefix}.${key}` : key;
-    const definition = schema[key];
-    result[newKey] = { ...definition, key: newKey };
-    if (definition.properties) {
-      result = { ...result, ...flattenSchema(definition.properties, newKey) };
-    }
-  }
-  return result;
-}
-
-const FLATTENED_SCHEMA = flattenSchema(SETTINGS_SCHEMA);
-
-/**
- * Get all settings grouped by category
- */
-export function getSettingsByCategory(): Record<
-  string,
-  Array<SettingDefinition & { key: string }>
-> {
-  const categories: Record<
-    string,
-    Array<SettingDefinition & { key: string }>
-  > = {};
-
-  Object.values(FLATTENED_SCHEMA).forEach((definition) => {
-    const category = definition.category;
-    if (!categories[category]) {
-      categories[category] = [];
-    }
-    categories[category].push(definition);
-  });
-
-  return categories;
-}
-
-/**
- * Get a setting definition by key
- */
-export function getSettingDefinition(
-  key: string,
-): (SettingDefinition & { key: string }) | undefined {
-  return FLATTENED_SCHEMA[key];
-}
-
-/**
- * Check if a setting requires restart
- */
-export function requiresRestart(key: string): boolean {
-  return FLATTENED_SCHEMA[key]?.requiresRestart ?? false;
-}
-
-/**
- * Get the default value for a setting
- */
-export function getDefaultValue(key: string): SettingDefinition['default'] {
-  return FLATTENED_SCHEMA[key]?.default;
-}
-
-/**
- * Get all setting keys that require restart
- */
-export function getRestartRequiredSettings(): string[] {
-  return Object.values(FLATTENED_SCHEMA)
-    .filter((definition) => definition.requiresRestart)
-    .map((definition) => definition.key);
-}
-
-/**
- * Recursively gets a value from a nested object using a key path array.
- */
-export function getNestedValue(
-  obj: Record<string, unknown>,
-  path: string[],
-): unknown {
-  const [first, ...rest] = path;
-  if (!first || !(first in obj)) {
-    return undefined;
-  }
-  const value = obj[first];
-  if (rest.length === 0) {
-    return value;
-  }
-  if (value && typeof value === 'object' && value !== null) {
-    return getNestedValue(value as Record<string, unknown>, rest);
-  }
-  return undefined;
-}
-
-/**
- * Get the effective value for a setting, considering inheritance from higher scopes
- * Always returns a value (never undefined) - falls back to default if not set anywhere
- */
-export function getEffectiveValue(
-  key: string,
-  settings: Settings,
-  mergedSettings: Settings,
-): SettingDefinition['default'] {
-  const definition = getSettingDefinition(key);
-  if (!definition) {
-    return undefined;
-  }
-
-  const path = key.split('.');
-
-  // Check the current scope's settings first
-  let value = getNestedValue(settings as Record<string, unknown>, path);
-  if (value !== undefined) {
-    return value as SettingDefinition['default'];
-  }
-
-  // Check the merged settings for an inherited value
-  value = getNestedValue(mergedSettings as Record<string, unknown>, path);
-  if (value !== undefined) {
-    return value as SettingDefinition['default'];
-  }
-
-  // Return default value if no value is set anywhere
-  return definition.default;
-}
-
-/**
- * Get all setting keys from the schema
- */
-export function getAllSettingKeys(): string[] {
-  return Object.keys(FLATTENED_SCHEMA);
-}
-
-/**
- * Get settings by type
- */
-export function getSettingsByType(
-  type: SettingDefinition['type'],
-): Array<SettingDefinition & { key: string }> {
-  return Object.values(FLATTENED_SCHEMA).filter(
-    (definition) => definition.type === type,
-  );
-}
-
-/**
- * Get settings that require restart
- */
-export function getSettingsRequiringRestart(): Array<
-  SettingDefinition & {
-    key: string;
-  }
-> {
-  return Object.values(FLATTENED_SCHEMA).filter(
-    (definition) => definition.requiresRestart,
-  );
-}
-
-/**
- * Validate if a setting key exists in the schema
- */
-export function isValidSettingKey(key: string): boolean {
-  return key in FLATTENED_SCHEMA;
-}
-
-/**
- * Get the category for a setting
- */
-export function getSettingCategory(key: string): string | undefined {
-  return FLATTENED_SCHEMA[key]?.category;
-}
-
-/**
- * Check if a setting should be shown in the settings dialog
- */
-export function shouldShowInDialog(key: string): boolean {
-  return FLATTENED_SCHEMA[key]?.showInDialog ?? true; // Default to true for backward compatibility
-}
-
-/**
- * Get all settings that should be shown in the dialog, grouped by category
- */
-export function getDialogSettingsByCategory(): Record<
-  string,
-  Array<SettingDefinition & { key: string }>
-> {
-  const categories: Record<
-    string,
-    Array<SettingDefinition & { key: string }>
-  > = {};
-
-  Object.values(FLATTENED_SCHEMA)
-    .filter((definition) => definition.showInDialog !== false)
-    .forEach((definition) => {
-      const category = definition.category;
-      if (!categories[category]) {
-        categories[category] = [];
-      }
-      categories[category].push(definition);
-    });
-
-  return categories;
-}
-
-/**
- * Get settings by type that should be shown in the dialog
- */
-export function getDialogSettingsByType(
-  type: SettingDefinition['type'],
-): Array<SettingDefinition & { key: string }> {
-  return Object.values(FLATTENED_SCHEMA).filter(
-    (definition) =>
-      definition.type === type && definition.showInDialog !== false,
-  );
-}
-
-/**
- * Get all setting keys that should be shown in the dialog
- */
-export function getDialogSettingKeys(): string[] {
-  return Object.values(FLATTENED_SCHEMA)
-    .filter((definition) => definition.showInDialog !== false)
-    .map((definition) => definition.key);
-}
-
-// ============================================================================
-// BUSINESS LOGIC UTILITIES (Higher-level utilities for setting operations)
-// ============================================================================
-
-/**
- * Get the current value for a setting in a specific scope
- * Always returns a value (never undefined) - falls back to default if not set anywhere
- */
-export function getSettingValue(
-  key: string,
-  settings: Settings,
-  mergedSettings: Settings,
-): boolean {
-  const definition = getSettingDefinition(key);
-  if (!definition) {
-    return false; // Default fallback for invalid settings
-  }
-
-  const value = getEffectiveValue(key, settings, mergedSettings);
-  // Ensure we return a boolean value, converting from the more general type
-  if (typeof value === 'boolean') {
-    return value;
-  }
-  // Fall back to default value, ensuring it's a boolean
-  const defaultValue = definition.default;
-  if (typeof defaultValue === 'boolean') {
-    return defaultValue;
-  }
-  return false; // Final fallback
-}
-
-/**
- * Check if a setting value is modified from its default
- */
-export function isSettingModified(key: string, value: boolean): boolean {
-  const defaultValue = getDefaultValue(key);
-  // Handle type comparison properly
-  if (typeof defaultValue === 'boolean') {
-    return value !== defaultValue;
-  }
-  // If default is not a boolean, consider it modified if value is true
-  return value === true;
-}
-
-/**
- * Check if a setting exists in the original settings file for a scope
- */
-export function settingExistsInScope(
-  key: string,
-  scopeSettings: Settings,
-): boolean {
-  const path = key.split('.');
-  const value = getNestedValue(scopeSettings as Record<string, unknown>, path);
-  return value !== undefined;
-}
-
-/**
- * Recursively sets a value in a nested object using a key path array.
- */
-function setNestedValue(
-  obj: Record<string, unknown>,
-  path: string[],
-  value: unknown,
-): Record<string, unknown> {
-  const [first, ...rest] = path;
-  if (!first) {
-    return obj;
-  }
-
-  if (rest.length === 0) {
-    obj[first] = value;
-    return obj;
-  }
-
-  if (!obj[first] || typeof obj[first] !== 'object') {
-    obj[first] = {};
-  }
-
-  setNestedValue(obj[first] as Record<string, unknown>, rest, value);
-  return obj;
-}
-
-/**
- * Set a setting value in the pending settings
- */
-export function setPendingSettingValue(
-  key: string,
-  value: boolean,
-  pendingSettings: Settings,
-): Settings {
-  const path = key.split('.');
-  const newSettings = JSON.parse(JSON.stringify(pendingSettings));
-  setNestedValue(newSettings, path, value);
-  return newSettings;
-}
-
-/**
- * Generic setter: Set a setting value (boolean, number, string, etc.) in the pending settings
- */
-export function setPendingSettingValueAny(
-  key: string,
-  value: unknown,
-  pendingSettings: Settings,
-): Settings {
-  const path = key.split('.');
-  const newSettings = structuredClone(pendingSettings);
-  setNestedValue(newSettings, path, value);
-  return newSettings;
-}
-
-/**
- * Check if any modified settings require a restart
- */
-export function hasRestartRequiredSettings(
-  modifiedSettings: Set<string>,
-): boolean {
-  return Array.from(modifiedSettings).some((key) => requiresRestart(key));
-}
-
-/**
- * Get the restart required settings from a set of modified settings
- */
-export function getRestartRequiredFromModified(
-  modifiedSettings: Set<string>,
-): string[] {
-  return Array.from(modifiedSettings).filter((key) => requiresRestart(key));
-}
-
-/**
- * Save modified settings to the appropriate scope
- */
-export function saveModifiedSettings(
-  modifiedSettings: Set<string>,
-  pendingSettings: Settings,
-  loadedSettings: LoadedSettings,
-  scope: SettingScope,
-): void {
-  modifiedSettings.forEach((settingKey) => {
-    const path = settingKey.split('.');
-    const value = getNestedValue(
-      pendingSettings as Record<string, unknown>,
-      path,
-    );
-
-    if (value === undefined) {
-      return;
-    }
-
-    const existsInOriginalFile = settingExistsInScope(
-      settingKey,
-      loadedSettings.forScope(scope).settings,
-    );
-
-    const isDefaultValue = value === getDefaultValue(settingKey);
-
-    if (existsInOriginalFile || !isDefaultValue) {
-      // This is tricky because setValue only works on top-level keys.
-      // We need to set the whole parent object.
-      const [parentKey] = path;
-      if (parentKey) {
-        const newParentValue = setPendingSettingValueAny(
-          settingKey,
-          value,
-          loadedSettings.forScope(scope).settings,
-        )[parentKey as keyof Settings];
-
-        loadedSettings.setValue(
-          scope,
-          parentKey as keyof Settings,
-          newParentValue,
-        );
-      }
-    }
-  });
-}
-
-/**
- * Get the display value for a setting, showing current scope value with default change indicator
- */
-export function getDisplayValue(
-  key: string,
-  settings: Settings,
-  _mergedSettings: Settings,
-  modifiedSettings: Set<string>,
-  pendingSettings?: Settings,
-): string {
-  // Prioritize pending changes if user has modified this setting
-  let value: boolean;
-  if (pendingSettings && settingExistsInScope(key, pendingSettings)) {
-    // Show the value from the pending (unsaved) edits when it exists
-    value = getSettingValue(key, pendingSettings, {});
-  } else if (settingExistsInScope(key, settings)) {
-    // Show the value defined at the current scope if present
-    value = getSettingValue(key, settings, {});
-  } else {
-    // Fall back to the schema default when the key is unset in this scope
-    const defaultValue = getDefaultValue(key);
-    value = typeof defaultValue === 'boolean' ? defaultValue : false;
-  }
-
-  const valueString = String(value);
-
-  // Check if value is different from default OR if it's in modified settings OR if there are pending changes
-  const defaultValue = getDefaultValue(key);
-  const isChangedFromDefault =
-    typeof defaultValue === 'boolean' ? value !== defaultValue : value === true;
-  const isInModifiedSettings = modifiedSettings.has(key);
-
-  // Mark as modified if setting exists in current scope OR is in modified settings
-  if (settingExistsInScope(key, settings) || isInModifiedSettings) {
-    return `${valueString}*`; // * indicates setting is set in current scope
-  }
-  if (isChangedFromDefault || isInModifiedSettings) {
-    return `${valueString}*`; // * indicates changed from default value
-  }
-
-  return valueString;
-}
-
-/**
- * Check if a setting doesn't exist in current scope (should be greyed out)
- */
-export function isDefaultValue(key: string, settings: Settings): boolean {
-  return !settingExistsInScope(key, settings);
-}
-
-/**
- * Check if a setting value is inherited (not set at current scope)
- */
-export function isValueInherited(
-  key: string,
-  settings: Settings,
-  _mergedSettings: Settings,
-): boolean {
-  return !settingExistsInScope(key, settings);
-}
-
-/**
- * Get the effective value for display, considering inheritance
- * Always returns a boolean value (never undefined)
- */
-export function getEffectiveDisplayValue(
-  key: string,
-  settings: Settings,
-  mergedSettings: Settings,
-): boolean {
-  return getSettingValue(key, settings, mergedSettings);
-}

package/dist/utils/spawnWrapper.ts

@@ -1,9 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { spawn } from 'child_process';
-
-export const spawnWrapper = spawn;

package/dist/utils/startupWarnings.test.ts

@@ -1,83 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { getStartupWarnings } from './startupWarnings.js';
-import { getErrorMessage } from 'fss-link-core';
-import fs from 'fs/promises';
-
-// Mock fs/promises with proper factory
-vi.mock('fs/promises', () => ({
-  default: {
-    access: vi.fn(),
-    readFile: vi.fn(),
-    unlink: vi.fn(),
-  },
-}));
-
-vi.mock('fss-link-core', async (importOriginal) => {
-  const actual = await importOriginal();
-  return {
-    ...actual,
-    getErrorMessage: vi.fn(),
-  };
-});
-
-describe('startupWarnings', () => {
-  beforeEach(() => {
-    vi.resetAllMocks();
-  });
-
-  it('should return warnings from the file and delete it', async () => {
-    const mockWarnings = 'Warning 1\nWarning 2';
-    vi.mocked(fs.access).mockResolvedValue(undefined);
-    vi.mocked(fs.readFile).mockResolvedValue(mockWarnings);
-    vi.mocked(fs.unlink).mockResolvedValue(undefined);
-
-    const warnings = await getStartupWarnings();
-
-    expect(fs.access).toHaveBeenCalled();
-    expect(fs.readFile).toHaveBeenCalled();
-    expect(fs.unlink).toHaveBeenCalled();
-    expect(warnings).toEqual(['Warning 1', 'Warning 2']);
-  });
-
-  it('should return an empty array if the file does not exist', async () => {
-    const error = new Error('File not found');
-    (error as Error & { code: string }).code = 'ENOENT';
-    vi.mocked(fs.access).mockRejectedValue(error);
-
-    const warnings = await getStartupWarnings();
-
-    expect(warnings).toEqual([]);
-  });
-
-  it('should return an error message if reading the file fails', async () => {
-    const error = new Error('Permission denied');
-    vi.mocked(fs.access).mockRejectedValue(error);
-    vi.mocked(getErrorMessage).mockReturnValue('Permission denied');
-
-    const warnings = await getStartupWarnings();
-
-    expect(warnings).toEqual([
-      'Error checking/reading warnings file: Permission denied',
-    ]);
-  });
-
-  it('should return a warning if deleting the file fails', async () => {
-    const mockWarnings = 'Warning 1';
-    vi.mocked(fs.access).mockResolvedValue(undefined);
-    vi.mocked(fs.readFile).mockResolvedValue(mockWarnings);
-    vi.mocked(fs.unlink).mockRejectedValue(new Error('Permission denied'));
-
-    const warnings = await getStartupWarnings();
-
-    expect(warnings).toEqual([
-      'Warning 1',
-      'Warning: Could not delete temporary warnings file.',
-    ]);
-  });
-});

package/dist/utils/startupWarnings.ts

@@ -1,40 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import fs from 'fs/promises';
-import os from 'os';
-import { join as pathJoin } from 'node:path';
-import { getErrorMessage } from 'fss-link-core';
-
-const warningsFilePath = pathJoin(os.tmpdir(), 'fss-link-warnings.txt');
-
-export async function getStartupWarnings(): Promise<string[]> {
-  try {
-    await fs.access(warningsFilePath); // Check if file exists
-    const warningsContent = await fs.readFile(warningsFilePath, 'utf-8');
-    const warnings = warningsContent
-      .split('\n')
-      .filter((line) => line.trim() !== '');
-    try {
-      await fs.unlink(warningsFilePath);
-    } catch {
-      warnings.push('Warning: Could not delete temporary warnings file.');
-    }
-    return warnings;
-  } catch (err: unknown) {
-    // If fs.access throws, it means the file doesn't exist or is not accessible.
-    // This is not an error in the context of fetching warnings, so return empty.
-    // Only return an error message if it's not a "file not found" type error.
-    // However, the original logic returned an error message for any fs.existsSync failure.
-    // To maintain closer parity while making it async, we'll check the error code.
-    // ENOENT is "Error NO ENTry" (file not found).
-    if (err instanceof Error && 'code' in err && err.code === 'ENOENT') {
-      return []; // File not found, no warnings to return.
-    }
-    // For other errors (permissions, etc.), return the error message.
-    return [`Error checking/reading warnings file: ${getErrorMessage(err)}`];
-  }
-}

package/dist/utils/updateEventEmitter.ts

@@ -1,13 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { EventEmitter } from 'events';
-
-/**
- * A shared event emitter for application-wide communication
- * between decoupled parts of the CLI.
- */
-export const updateEventEmitter = new EventEmitter();