@lkangd/cc-env 1.1.1 → 1.2.0

package/src/flows/init-flow.ts

@@ -1,61 +0,0 @@
-export type InitFlowStep = 'keys' | 'confirm' | 'done'
-
-export type InitFlowState = {
-  step: InitFlowStep
-  availableKeys: string[]
-  requiredKeys: string[]
-  selectedKeys: string[]
-}
-
-export type InitFlowAction =
-  | { type: 'toggle-key'; key: string }
-  | { type: 'continue' }
-  | { type: 'confirm' }
-
-export function createInitFlowState(
-  availableKeys: string[],
-  requiredKeys: string[],
-): InitFlowState {
-  return {
-    step: 'keys',
-    availableKeys,
-    requiredKeys,
-    selectedKeys: requiredKeys,
-  }
-}
-
-export function advanceInitFlow(
-  state: InitFlowState,
-  action: InitFlowAction,
-): InitFlowState {
-  if (state.step === 'keys' && action.type === 'toggle-key') {
-    if (state.requiredKeys.includes(action.key)) {
-      return state
-    }
-
-    const selectedKeys = state.selectedKeys.includes(action.key)
-      ? state.selectedKeys.filter((key) => key !== action.key)
-      : [...state.selectedKeys, action.key]
-
-    return {
-      ...state,
-      selectedKeys,
-    }
-  }
-
-  if (state.step === 'keys' && action.type === 'continue') {
-    return {
-      ...state,
-      step: 'confirm',
-    }
-  }
-
-  if (state.step === 'confirm' && action.type === 'confirm') {
-    return {
-      ...state,
-      step: 'done',
-    }
-  }
-
-  return state
-}

package/src/flows/preset-create-flow.ts

@@ -1,129 +0,0 @@
-import type { EnvMap } from '../core/schema.js'
-
-export type PresetCreateSource = 'file' | 'manual'
-export type PresetCreateDestination = 'global' | 'project'
-
-export type PresetCreateStep =
-  | 'source'
-  | 'filePath'
-  | 'keys'
-  | 'manualInput'
-  | 'name'
-  | 'destination'
-  | 'confirm'
-  | 'done'
-
-export type PresetCreateFlowState = {
-  step: PresetCreateStep
-  source?: PresetCreateSource
-  filePath?: string
-  env: EnvMap
-  allKeys: string[]
-  selectedKeys: string[]
-  presetName: string
-  destination?: PresetCreateDestination
-  error?: string | undefined
-}
-
-export type PresetCreateFlowResult = Pick<
-  PresetCreateFlowState,
-  'source' | 'env' | 'selectedKeys' | 'presetName' | 'destination'
-> & {
-  filePath?: string | undefined
-}
-
-export type PresetCreateFlowAction =
-  | { type: 'select-source'; source: PresetCreateSource }
-  | { type: 'set-file-path'; filePath: string }
-  | { type: 'set-error'; error: string }
-  | { type: 'select-keys'; keys: string[]; env: EnvMap }
-  | { type: 'add-manual-pair'; key: string; value: string }
-  | { type: 'finish-manual-input' }
-  | { type: 'set-name'; name: string }
-  | { type: 'select-destination'; destination: PresetCreateDestination }
-  | { type: 'confirm' }
-
-export function createPresetCreateFlowState(): PresetCreateFlowState {
-  return {
-    step: 'source',
-    env: {},
-    allKeys: [],
-    selectedKeys: [],
-    presetName: '',
-  }
-}
-
-export function advancePresetCreateFlow(
-  state: PresetCreateFlowState,
-  action: PresetCreateFlowAction,
-): PresetCreateFlowState {
-  switch (state.step) {
-    case 'source':
-      if (action.type !== 'select-source') return state
-      return {
-        ...state,
-        step: action.source === 'file' ? 'filePath' : 'manualInput',
-        source: action.source,
-      }
-
-    case 'filePath':
-      if (action.type === 'set-error') {
-        return { ...state, error: action.error }
-      }
-      if (action.type !== 'set-file-path') return state
-      return {
-        ...state,
-        step: 'keys',
-        filePath: action.filePath,
-        error: undefined,
-      }
-
-    case 'keys':
-      if (action.type !== 'select-keys') return state
-      return {
-        ...state,
-        step: 'name',
-        selectedKeys: action.keys,
-        env: action.env,
-      }
-
-    case 'manualInput':
-      if (action.type === 'add-manual-pair') {
-        const hasKey = state.selectedKeys.includes(action.key)
-        return {
-          ...state,
-          env: { ...state.env, [action.key]: action.value },
-          selectedKeys: hasKey ? state.selectedKeys : [...state.selectedKeys, action.key],
-          error: undefined,
-        }
-      }
-      if (action.type === 'set-error') {
-        return { ...state, error: action.error }
-      }
-      if (action.type !== 'finish-manual-input') return state
-      return { ...state, step: 'name' }
-
-    case 'name':
-      if (action.type !== 'set-name') return state
-      return {
-        ...state,
-        step: 'destination',
-        presetName: action.name,
-      }
-
-    case 'destination':
-      if (action.type !== 'select-destination') return state
-      return {
-        ...state,
-        step: 'confirm',
-        destination: action.destination,
-      }
-
-    case 'confirm':
-      if (action.type !== 'confirm') return state
-      return { ...state, step: 'done' }
-
-    case 'done':
-      return state
-  }
-}

package/src/flows/restore-flow.ts

@@ -1,144 +0,0 @@
-import type { HistoryRecord } from '../core/schema.js'
-
-export type RestoreFlowStep = 'record' | 'target' | 'confirm' | 'done'
-
-type BaseRestoreFlowState = {
-  records: HistoryRecord[]
-  selectedTimestamp?: string
-}
-
-export type RestoreFlowState =
-  | ({ step: 'record' } & BaseRestoreFlowState)
-  | ({ step: 'target'; selectedTimestamp: string } & BaseRestoreFlowState)
-  | ({ step: 'confirm'; selectedTimestamp: string } & BaseRestoreFlowState & (
-      | {
-          targetType: 'settings'
-        }
-      | {
-          targetType: 'preset'
-          targetName: string
-        }
-    ))
-  | ({ step: 'done'; selectedTimestamp: string } & BaseRestoreFlowState & (
-      | {
-          targetType: 'settings'
-        }
-      | {
-          targetType: 'preset'
-          targetName: string
-        }
-    ))
-
-export type RestoreFlowAction =
-  | {
-      type: 'select-record'
-      timestamp: string
-    }
-  | {
-      type: 'select-target'
-      targetType: 'settings' | 'preset'
-      targetName?: string
-    }
-  | {
-      type: 'confirm'
-    }
-
-export function createRestoreFlowState(records: HistoryRecord[]): RestoreFlowState {
-  return {
-    step: 'record',
-    records,
-  }
-}
-
-export function advanceRestoreFlow(
-  state: RestoreFlowState,
-  action: RestoreFlowAction,
-): RestoreFlowState {
-  switch (state.step) {
-    case 'record': {
-      if (action.type !== 'select-record') {
-        return state
-      }
-
-      const selectedRecord = state.records.find(
-        (record) => record.timestamp === action.timestamp,
-      )
-
-      if (!selectedRecord) {
-        return state
-      }
-
-      if (selectedRecord.action === 'init') {
-        return {
-          ...state,
-          step: 'confirm',
-          selectedTimestamp: action.timestamp,
-        } as RestoreFlowState
-      }
-
-      return {
-        ...state,
-        step: 'target',
-        selectedTimestamp: action.timestamp,
-      }
-    }
-
-    case 'target':
-      if (action.type !== 'select-target' || !state.selectedTimestamp) {
-        return state
-      }
-
-      if (action.targetType === 'preset' && !action.targetName) {
-        return state
-      }
-
-      if (action.targetType === 'settings') {
-        return {
-          ...state,
-          step: 'confirm',
-          targetType: 'settings',
-        }
-      }
-
-      const targetName = action.targetName as string
-
-      return {
-        ...state,
-        step: 'confirm',
-        targetType: 'preset',
-        targetName,
-      }
-
-    case 'confirm':
-      if (action.type !== 'confirm' || !state.selectedTimestamp) {
-        return state
-      }
-
-      const selectedRecord = state.records.find(
-        (record) => record.timestamp === state.selectedTimestamp,
-      )
-
-      if (selectedRecord?.action === 'init') {
-        return {
-          ...state,
-          step: 'done',
-        } as RestoreFlowState
-      }
-
-      if (!state.targetType) {
-        return state
-      }
-
-      if (state.targetType === 'preset' && !state.targetName) {
-        return state
-      }
-
-      return {
-        ...state,
-        step: 'done',
-      }
-
-    case 'done':
-      return state
-  }
-}

package/src/ink/init-app.tsx

@@ -1,110 +0,0 @@
-import React, { useEffect, useState } from 'react'
-import { Box, Text, useApp, useInput } from 'ink'
-
-import {
-  advanceInitFlow,
-  createInitFlowState,
-} from '../flows/init-flow.js'
-
-export function InitApp({
-  keys = [],
-  requiredKeys = [],
-  sourceFiles = [],
-  onSubmit,
-}: {
-  keys?: string[]
-  requiredKeys?: string[]
-  sourceFiles?: string[]
-  onSubmit?: (result: { confirmed: boolean; selectedKeys: string[] }) => void
-}) {
-  const { exit } = useApp()
-  const [cursor, setCursor] = useState(0)
-  const [flowState, setFlowState] = useState(() =>
-    createInitFlowState(keys, requiredKeys),
-  )
-
-  useEffect(() => {
-    if (!onSubmit) {
-      return
-    }
-
-    if (keys.length === 0) {
-      onSubmit({ confirmed: false, selectedKeys: [] })
-      exit()
-    }
-  }, [exit, keys.length, onSubmit])
-
-  useInput((input, key) => {
-    if (!onSubmit) {
-      return
-    }
-
-    if (key.upArrow || input === 'k') {
-      setCursor((c) => Math.max(0, c - 1))
-      return
-    }
-
-    if (key.downArrow || input === 'j') {
-      setCursor((c) => Math.min(keys.length - 1, c + 1))
-      return
-    }
-
-    if (input === ' ') {
-      const targetKey = keys[cursor]
-      if (targetKey) {
-        setFlowState((prev) =>
-          advanceInitFlow(prev, { type: 'toggle-key', key: targetKey }),
-        )
-      }
-      return
-    }
-
-    if (key.return) {
-      onSubmit({ confirmed: true, selectedKeys: flowState.selectedKeys })
-      exit()
-      return
-    }
-
-    if (key.escape || input.toLowerCase() === 'q') {
-      onSubmit({ confirmed: false, selectedKeys: [] })
-      exit()
-    }
-  })
-
-  return (
-    <Box flexDirection="column">
-      <Text bold>Select env keys to migrate into managed shell config</Text>
-      {sourceFiles.length > 0 ? (
-        <Box flexDirection="column">
-          <Text dimColor>Source:</Text>
-          {sourceFiles.map((file) => (
-            <Text key={file} color="cyan">  {file}</Text>
-          ))}
-        </Box>
-      ) : null}
-      <Text dimColor>↑/k ↓/j navigate · space toggle · enter confirm · q cancel</Text>
-      <Box flexDirection="column" marginTop={1}>
-        {keys.map((key, i) => {
-          const isRequired = requiredKeys.includes(key)
-          const isSelected = flowState.selectedKeys.includes(key)
-          const isCursor = i === cursor
-          const checkbox = isSelected ? '[x]' : '[ ]'
-
-          return (
-            <Box key={key}>
-              <Text>{isCursor ? '❯ ' : '  '}</Text>
-              <Text color={isSelected ? 'green' : ''}>{checkbox}</Text>
-              <Text> {key}</Text>
-              {isRequired ? <Text dimColor> (required)</Text> : null}
-            </Box>
-          )
-        })}
-      </Box>
-      <Box marginTop={1}>
-        <Text dimColor>
-          {flowState.selectedKeys.length} of {keys.length} selected
-        </Text>
-      </Box>
-    </Box>
-  )
-}