@fgv/ts-res-ui-components 5.0.0-21 → 5.0.0-22

package/lib/namespaces/ResolutionTools.d.ts

@@ -34,7 +34,8 @@ export { QualifierContextControl } from '../components/common/QualifierContextCo
 export { ResolutionContextOptionsControl } from '../components/common/ResolutionContextOptionsControl';
 export { useResolutionState } from '../hooks/useResolutionState';
 export { createResolverWithContext, evaluateConditionsForCandidate, resolveResourceDetailed, getAvailableQualifiers, hasPendingContextChanges, type ResolutionOptions } from '../utils/resolutionUtils';
-export type { ResolutionState, ResolutionActions, ResolutionViewProps, ResolutionResult, CandidateInfo, ConditionEvaluationResult, EditedResourceInfo, ResolutionContextOptions, QualifierControlOptions } from '../types';
+export { getPendingAdditionsByType, isPendingAddition, deriveLeafId, deriveFullId, getPendingResourceTypes, getPendingResourceStats, validatePendingResourceKeys } from '../utils/resourceSelectors';
+export type { ResolutionState, ResolutionActions, ResolutionViewProps, ResolutionResult, CandidateInfo, ConditionEvaluationResult, EditedResourceInfo, ResolutionContextOptions, QualifierControlOptions, CreatePendingResourceParams } from '../types';
 export type { EditableJsonViewProps } from '../components/views/ResolutionView/EditableJsonView';
 export type { ResolutionContextOptionsControlProps } from '../components/common/ResolutionContextOptionsControl';
 //# sourceMappingURL=ResolutionTools.d.ts.map

package/lib/namespaces/ResolutionTools.js

@@ -38,4 +38,6 @@ export { ResolutionContextOptionsControl } from '../components/common/Resolution
 export { useResolutionState } from '../hooks/useResolutionState';
 // Export utility functions
 export { createResolverWithContext, evaluateConditionsForCandidate, resolveResourceDetailed, getAvailableQualifiers, hasPendingContextChanges } from '../utils/resolutionUtils';
+// Export resource selector utility functions for pending resource management
+export { getPendingAdditionsByType, isPendingAddition, deriveLeafId, deriveFullId, getPendingResourceTypes, getPendingResourceStats, validatePendingResourceKeys } from '../utils/resourceSelectors';
 //# sourceMappingURL=ResolutionTools.js.map

package/lib/test/unit/workflows/resolutionWorkflows.test.d.ts

@@ -0,0 +1,2 @@
+import '@fgv/ts-utils-jest';
+//# sourceMappingURL=resolutionWorkflows.test.d.ts.map

package/lib/test/unit/workflows/resourceCreation.test.d.ts

@@ -0,0 +1,2 @@
+import '@fgv/ts-utils-jest';
+//# sourceMappingURL=resourceCreation.test.d.ts.map

package/lib/test/unit/workflows/resultPatternExtensions.test.d.ts

@@ -0,0 +1,2 @@
+import '@fgv/ts-utils-jest';
+//# sourceMappingURL=resultPatternExtensions.test.d.ts.map

package/lib/test/unit/workflows/validation.test.d.ts

@@ -0,0 +1,2 @@
+import '@fgv/ts-utils-jest';
+//# sourceMappingURL=validation.test.d.ts.map

package/lib/types/index.d.ts

@@ -411,6 +411,58 @@ export interface ResolutionState {
     /** Whether there are pending resource additions or deletions */
     hasPendingResourceChanges: boolean;
 }
+/**
+ * Parameters for creating a pending resource atomically.
+ *
+ * @example
+ * ```typescript
+ * const params: CreatePendingResourceParams = {
+ *   id: 'platform.languages.az-AZ',
+ *   resourceTypeName: 'json',
+ *   json: { text: 'Welcome', locale: 'az-AZ' }
+ * };
+ * ```
+ *
+ * @public
+ */
+export interface CreatePendingResourceParams {
+    /** Full resource ID (e.g., 'platform.languages.az-AZ') - must be unique */
+    id: string;
+    /** Name of the resource type to use for validation and template creation */
+    resourceTypeName: string;
+    /** JSON content for the resource candidate. If undefined, the resource type's base template will be used. */
+    json?: JsonValue;
+}
+/**
+ * Parameters for starting a new resource with optional pre-seeding.
+ *
+ * @example
+ * ```typescript
+ * // Basic start with just type
+ * const basicParams: StartNewResourceParams = {
+ *   defaultTypeName: 'json'
+ * };
+ *
+ * // Pre-seeded start with full data
+ * const preSeededParams: StartNewResourceParams = {
+ *   id: 'user.welcome',
+ *   resourceTypeName: 'json',
+ *   json: { text: 'Welcome!' }
+ * };
+ * ```
+ *
+ * @public
+ */
+export interface StartNewResourceParams {
+    /** Resource type to use (optional - will use first available if not provided) */
+    defaultTypeName?: string;
+    /** Pre-seed with specific ID (optional) */
+    id?: string;
+    /** Pre-seed with specific resource type name (optional) */
+    resourceTypeName?: string;
+    /** Pre-seed with specific JSON content (optional) */
+    json?: JsonValue;
+}
 /**
  * Actions available for managing resource resolution testing and editing.
  * Provides methods for context management, resource selection, and value editing.
@@ -419,41 +471,70 @@ export interface ResolutionState {
  */
 export interface ResolutionActions {
     /** Update a context value for resolution testing */
-    updateContextValue: (qualifierName: string, value: string | undefined) => void;
+    updateContextValue: (qualifierName: string, value: string | undefined) => Result<void>;
     /** Apply pending context changes to the resolver (with optional host-managed values) */
-    applyContext: (hostManagedValues?: Record<string, string | undefined>) => void;
+    applyContext: (hostManagedValues?: Record<string, string | undefined>) => Result<void>;
     /** Select a resource for detailed resolution testing */
-    selectResource: (resourceId: string) => void;
+    selectResource: (resourceId: string) => Result<void>;
     /** Change how resolution results are displayed */
     setViewMode: (mode: 'composed' | 'best' | 'all' | 'raw') => void;
     /** Clear the resolution cache to force fresh resolution */
-    resetCache: () => void;
+    resetCache: () => Result<void>;
     /** Save an edit to a resource value */
-    saveEdit: (resourceId: string, editedValue: JsonValue, originalValue?: JsonValue) => void;
+    saveEdit: (resourceId: string, editedValue: JsonValue, originalValue?: JsonValue) => Result<void>;
     /** Get the edited value for a resource, if any */
     getEditedValue: (resourceId: string) => JsonValue | undefined;
     /** Check if a resource has been edited */
     hasEdit: (resourceId: string) => boolean;
     /** Clear all pending edits */
-    clearEdits: () => void;
+    clearEdits: () => Result<{
+        clearedCount: number;
+    }>;
     /** Discard all pending edits */
-    discardEdits: () => void;
-    /** Start creating a new resource */
-    startNewResource: (defaultTypeName?: string) => void;
+    discardEdits: () => Result<{
+        discardedCount: number;
+    }>;
+    /** Create a pending resource atomically with validation */
+    createPendingResource: (params: CreatePendingResourceParams) => Result<void>;
+    /** Start creating a new resource (enhanced with optional pre-seeding) */
+    startNewResource: (params?: StartNewResourceParams) => Result<{
+        draft: ResolutionState['newResourceDraft'];
+        diagnostics: string[];
+    }>;
     /** Update the resource ID for the new resource being created */
-    updateNewResourceId: (id: string) => void;
+    updateNewResourceId: (id: string) => Result<{
+        draft: ResolutionState['newResourceDraft'];
+        diagnostics: string[];
+    }>;
     /** Select a resource type for the new resource */
-    selectResourceType: (type: string) => void;
+    selectResourceType: (type: string) => Result<{
+        draft: ResolutionState['newResourceDraft'];
+        diagnostics: string[];
+    }>;
+    /** Update the JSON content for the new resource being created */
+    updateNewResourceJson: (json: JsonValue) => Result<{
+        draft: ResolutionState['newResourceDraft'];
+        diagnostics: string[];
+    }>;
     /** Add the new resource to pending resources (not applied yet) */
-    saveNewResourceAsPending: () => void;
+    saveNewResourceAsPending: () => Result<{
+        pendingResources: Map<string, ResourceJson.Json.ILooseResourceDecl>;
+        diagnostics: string[];
+    }>;
     /** Cancel the new resource creation */
     cancelNewResource: () => void;
     /** Remove a pending resource */
-    removePendingResource: (resourceId: string) => void;
+    removePendingResource: (resourceId: string) => Result<void>;
     /** Mark an existing resource for deletion */
     markResourceForDeletion: (resourceId: string) => void;
     /** Apply all pending resource additions and deletions */
-    applyPendingResources: () => Promise<void>;
+    applyPendingResources: () => Promise<Result<{
+        appliedCount: number;
+        existingResourceEditCount: number;
+        pendingResourceEditCount: number;
+        newResourceCount: number;
+        deletionCount: number;
+    }>>;
     /** Discard all pending resource changes */
     discardPendingResources: () => void;
 }
@@ -1176,14 +1257,37 @@ export interface OrchestratorActions {
     hasResourceEdit: (resourceId: string) => boolean;
     clearResourceEdits: () => void;
     discardResourceEdits: () => void;
-    startNewResource: (defaultTypeName?: string) => void;
-    updateNewResourceId: (id: string) => void;
-    selectResourceType: (type: string) => void;
-    saveNewResourceAsPending: () => void;
+    createPendingResource: (params: CreatePendingResourceParams) => Result<void>;
+    startNewResource: (params?: StartNewResourceParams) => Result<{
+        draft: ResolutionState['newResourceDraft'];
+        diagnostics: string[];
+    }>;
+    updateNewResourceId: (id: string) => Result<{
+        draft: ResolutionState['newResourceDraft'];
+        diagnostics: string[];
+    }>;
+    selectResourceType: (type: string) => Result<{
+        draft: ResolutionState['newResourceDraft'];
+        diagnostics: string[];
+    }>;
+    updateNewResourceJson: (json: JsonValue) => Result<{
+        draft: ResolutionState['newResourceDraft'];
+        diagnostics: string[];
+    }>;
+    saveNewResourceAsPending: () => Result<{
+        pendingResources: Map<string, ResourceJson.Json.ILooseResourceDecl>;
+        diagnostics: string[];
+    }>;
     cancelNewResource: () => void;
     removePendingResource: (resourceId: string) => void;
     markResourceForDeletion: (resourceId: string) => void;
-    applyPendingResources: () => Promise<void>;
+    applyPendingResources: () => Promise<Result<{
+        appliedCount: number;
+        existingResourceEditCount: number;
+        pendingResourceEditCount: number;
+        newResourceCount: number;
+        deletionCount: number;
+    }>>;
     discardPendingResources: () => void;
     selectResource: (resourceId: string | null) => void;
     addMessage: (type: Message['type'], message: string) => void;
@@ -1192,4 +1296,5 @@ export interface OrchestratorActions {
 }
 export type { Result } from '@fgv/ts-utils';
 export type { JsonValue } from '@fgv/ts-json-base';
+export { getPendingAdditionsByType, isPendingAddition, deriveLeafId, deriveFullId, getPendingResourceTypes, getPendingResourceStats, validatePendingResourceKeys } from '../utils/resourceSelectors';
 //# sourceMappingURL=index.d.ts.map

package/lib/types/index.js

@@ -1,2 +1,3 @@
-export {};
+// Resource selector utility functions
+export { getPendingAdditionsByType, isPendingAddition, deriveLeafId, deriveFullId, getPendingResourceTypes, getPendingResourceStats, validatePendingResourceKeys } from '../utils/resourceSelectors';
 //# sourceMappingURL=index.js.map

package/lib/utils/resolutionEditing.js

@@ -1,6 +1,7 @@
 import { succeed, fail } from '@fgv/ts-utils';
 import { Runtime } from '@fgv/ts-res';
 import { Diff } from '@fgv/ts-json';
+import { isJsonObject } from '@fgv/ts-json-base';
 /**
  * Validates an edited resource JSON value
  */
@@ -67,7 +68,7 @@ export function computeResourceDelta(baseValue, resolvedValue, editedValue) {
  * Recursively adds null values to delta for all properties in the deleted object
  */
 function addDeletionsAsNull(deleted, delta) {
-    if (typeof deleted === 'object' && deleted !== null && !Array.isArray(deleted)) {
+    if (isJsonObject(deleted)) {
         const deletedObj = deleted;
         for (const key in deletedObj) {
             if (deletedObj.hasOwnProperty(key)) {

package/lib/utils/resourceSelectors.d.ts

@@ -0,0 +1,146 @@
+import { ResourceJson } from '@fgv/ts-res';
+import { Result } from '@fgv/ts-utils';
+/**
+ * Helper functions for working with pending resources and resource IDs.
+ * These utilities provide standardized ways to work with resource identification
+ * and selection patterns commonly needed by host applications.
+ *
+ * @public
+ */
+/**
+ * Gets pending resources filtered by resource type.
+ *
+ * @param pendingResources - Map of pending resources (keys are guaranteed to be full resource IDs)
+ * @param resourceType - Resource type to filter by (e.g., 'json', 'string')
+ * @returns Array of pending resources of the specified type
+ *
+ * @example
+ * ```typescript
+ * const jsonResources = getPendingAdditionsByType(pendingResources, 'json');
+ * const languageConfigs = getPendingAdditionsByType(pendingResources, 'languageConfig');
+ * ```
+ *
+ * @public
+ */
+export declare function getPendingAdditionsByType(pendingResources: Map<string, ResourceJson.Json.ILooseResourceDecl>, resourceType: string): Array<{
+    id: string;
+    resource: ResourceJson.Json.ILooseResourceDecl;
+}>;
+/**
+ * Checks if a resource ID corresponds to a pending addition.
+ *
+ * @param resourceId - Resource ID to check (should be full resource ID)
+ * @param pendingResources - Map of pending resources
+ * @returns True if the resource ID exists in pending resources
+ *
+ * @example
+ * ```typescript
+ * if (isPendingAddition('platform.languages.az-AZ', pendingResources)) {
+ *   console.log('This is a pending resource');
+ * }
+ * ```
+ *
+ * @public
+ */
+export declare function isPendingAddition(resourceId: string, pendingResources: Map<string, ResourceJson.Json.ILooseResourceDecl>): boolean;
+/**
+ * Derives a leaf ID from a full resource ID.
+ * Extracts the last segment after the final dot.
+ *
+ * @param fullResourceId - Full resource ID (e.g., 'platform.languages.az-AZ')
+ * @returns Result containing the leaf ID (e.g., 'az-AZ') or error if invalid format
+ *
+ * @example
+ * ```typescript
+ * const leafResult = deriveLeafId('platform.languages.az-AZ');
+ * if (leafResult.isSuccess()) {
+ *   console.log(leafResult.value); // 'az-AZ'
+ * }
+ *
+ * const invalidResult = deriveLeafId('invalid');
+ * if (invalidResult.isFailure()) {
+ *   console.log(invalidResult.message); // 'Resource ID must contain at least one dot'
+ * }
+ * ```
+ *
+ * @public
+ */
+export declare function deriveLeafId(fullResourceId: string): Result<string>;
+/**
+ * Constructs a full resource ID from a root path and leaf ID.
+ *
+ * @param rootPath - Root path (e.g., 'platform.languages')
+ * @param leafId - Leaf identifier (e.g., 'az-AZ')
+ * @returns Result containing the full resource ID or error if invalid inputs
+ *
+ * @example
+ * ```typescript
+ * const fullIdResult = deriveFullId('platform.languages', 'az-AZ');
+ * if (fullIdResult.isSuccess()) {
+ *   console.log(fullIdResult.value); // 'platform.languages.az-AZ'
+ * }
+ *
+ * const invalidResult = deriveFullId('', 'az-AZ');
+ * if (invalidResult.isFailure()) {
+ *   console.log(invalidResult.message); // 'Root path cannot be empty'
+ * }
+ * ```
+ *
+ * @public
+ */
+export declare function deriveFullId(rootPath: string, leafId: string): Result<string>;
+/**
+ * Gets all unique resource types from pending resources.
+ *
+ * @param pendingResources - Map of pending resources
+ * @returns Array of unique resource type names
+ *
+ * @example
+ * ```typescript
+ * const types = getPendingResourceTypes(pendingResources);
+ * console.log(types); // ['json', 'string', 'languageConfig']
+ * ```
+ *
+ * @public
+ */
+export declare function getPendingResourceTypes(pendingResources: Map<string, ResourceJson.Json.ILooseResourceDecl>): string[];
+/**
+ * Gets statistics about pending resources.
+ * Provides summary information useful for UI displays.
+ *
+ * @param pendingResources - Map of pending resources
+ * @returns Statistics object with counts and breakdowns
+ *
+ * @example
+ * ```typescript
+ * const stats = getPendingResourceStats(pendingResources);
+ * console.log(`${stats.totalCount} pending resources`);
+ * console.log(`Types: ${Object.keys(stats.byType).join(', ')}`);
+ * ```
+ *
+ * @public
+ */
+export declare function getPendingResourceStats(pendingResources: Map<string, ResourceJson.Json.ILooseResourceDecl>): {
+    totalCount: number;
+    byType: Record<string, number>;
+    resourceIds: string[];
+};
+/**
+ * Validates that all keys in a pending resources map are properly formatted as full resource IDs.
+ * This is a diagnostic function to ensure the pending resource key invariant is maintained.
+ *
+ * @param pendingResources - Map of pending resources to validate
+ * @returns Result indicating whether all keys are valid full resource IDs, or details about any issues found
+ *
+ * @example
+ * ```typescript
+ * const validation = validatePendingResourceKeys(pendingResources);
+ * if (validation.isFailure()) {
+ *   console.error('Pending resource key validation failed:', validation.message);
+ * }
+ * ```
+ *
+ * @public
+ */
+export declare function validatePendingResourceKeys(pendingResources: Map<string, ResourceJson.Json.ILooseResourceDecl>): Result<void>;
+//# sourceMappingURL=resourceSelectors.d.ts.map

package/lib/utils/resourceSelectors.js

@@ -0,0 +1,233 @@
+import { succeed, fail } from '@fgv/ts-utils';
+/**
+ * Helper functions for working with pending resources and resource IDs.
+ * These utilities provide standardized ways to work with resource identification
+ * and selection patterns commonly needed by host applications.
+ *
+ * @public
+ */
+/**
+ * Gets pending resources filtered by resource type.
+ *
+ * @param pendingResources - Map of pending resources (keys are guaranteed to be full resource IDs)
+ * @param resourceType - Resource type to filter by (e.g., 'json', 'string')
+ * @returns Array of pending resources of the specified type
+ *
+ * @example
+ * ```typescript
+ * const jsonResources = getPendingAdditionsByType(pendingResources, 'json');
+ * const languageConfigs = getPendingAdditionsByType(pendingResources, 'languageConfig');
+ * ```
+ *
+ * @public
+ */
+export function getPendingAdditionsByType(pendingResources, resourceType) {
+    const results = [];
+    pendingResources.forEach((resource, id) => {
+        if (resource.resourceTypeName === resourceType) {
+            results.push({ id, resource });
+        }
+    });
+    return results;
+}
+/**
+ * Checks if a resource ID corresponds to a pending addition.
+ *
+ * @param resourceId - Resource ID to check (should be full resource ID)
+ * @param pendingResources - Map of pending resources
+ * @returns True if the resource ID exists in pending resources
+ *
+ * @example
+ * ```typescript
+ * if (isPendingAddition('platform.languages.az-AZ', pendingResources)) {
+ *   console.log('This is a pending resource');
+ * }
+ * ```
+ *
+ * @public
+ */
+export function isPendingAddition(resourceId, pendingResources) {
+    return pendingResources.has(resourceId);
+}
+/**
+ * Derives a leaf ID from a full resource ID.
+ * Extracts the last segment after the final dot.
+ *
+ * @param fullResourceId - Full resource ID (e.g., 'platform.languages.az-AZ')
+ * @returns Result containing the leaf ID (e.g., 'az-AZ') or error if invalid format
+ *
+ * @example
+ * ```typescript
+ * const leafResult = deriveLeafId('platform.languages.az-AZ');
+ * if (leafResult.isSuccess()) {
+ *   console.log(leafResult.value); // 'az-AZ'
+ * }
+ *
+ * const invalidResult = deriveLeafId('invalid');
+ * if (invalidResult.isFailure()) {
+ *   console.log(invalidResult.message); // 'Resource ID must contain at least one dot'
+ * }
+ * ```
+ *
+ * @public
+ */
+export function deriveLeafId(fullResourceId) {
+    if (!fullResourceId || fullResourceId.trim().length === 0) {
+        return fail('Resource ID cannot be empty');
+    }
+    const parts = fullResourceId.split('.');
+    if (parts.length < 2) {
+        return fail('Resource ID must contain at least one dot separator (e.g., "platform.languages.az-AZ")');
+    }
+    const leafId = parts[parts.length - 1];
+    if (!leafId || leafId.trim().length === 0) {
+        return fail('Leaf ID cannot be empty (resource ID cannot end with a dot)');
+    }
+    return succeed(leafId);
+}
+/**
+ * Constructs a full resource ID from a root path and leaf ID.
+ *
+ * @param rootPath - Root path (e.g., 'platform.languages')
+ * @param leafId - Leaf identifier (e.g., 'az-AZ')
+ * @returns Result containing the full resource ID or error if invalid inputs
+ *
+ * @example
+ * ```typescript
+ * const fullIdResult = deriveFullId('platform.languages', 'az-AZ');
+ * if (fullIdResult.isSuccess()) {
+ *   console.log(fullIdResult.value); // 'platform.languages.az-AZ'
+ * }
+ *
+ * const invalidResult = deriveFullId('', 'az-AZ');
+ * if (invalidResult.isFailure()) {
+ *   console.log(invalidResult.message); // 'Root path cannot be empty'
+ * }
+ * ```
+ *
+ * @public
+ */
+export function deriveFullId(rootPath, leafId) {
+    if (!rootPath || rootPath.trim().length === 0) {
+        return fail('Root path cannot be empty');
+    }
+    if (!leafId || leafId.trim().length === 0) {
+        return fail('Leaf ID cannot be empty');
+    }
+    // Remove leading/trailing dots from root path
+    const cleanRootPath = rootPath.replace(/^\.+|\.+$/g, '');
+    if (cleanRootPath.length === 0) {
+        return fail('Root path cannot consist only of dots');
+    }
+    // Remove leading/trailing dots from leaf ID
+    const cleanLeafId = leafId.replace(/^\.+|\.+$/g, '');
+    if (cleanLeafId.length === 0) {
+        return fail('Leaf ID cannot consist only of dots');
+    }
+    const fullId = `${cleanRootPath}.${cleanLeafId}`;
+    return succeed(fullId);
+}
+/**
+ * Gets all unique resource types from pending resources.
+ *
+ * @param pendingResources - Map of pending resources
+ * @returns Array of unique resource type names
+ *
+ * @example
+ * ```typescript
+ * const types = getPendingResourceTypes(pendingResources);
+ * console.log(types); // ['json', 'string', 'languageConfig']
+ * ```
+ *
+ * @public
+ */
+export function getPendingResourceTypes(pendingResources) {
+    const types = new Set();
+    pendingResources.forEach((resource) => {
+        if (resource.resourceTypeName) {
+            types.add(resource.resourceTypeName);
+        }
+    });
+    return Array.from(types).sort();
+}
+/**
+ * Gets statistics about pending resources.
+ * Provides summary information useful for UI displays.
+ *
+ * @param pendingResources - Map of pending resources
+ * @returns Statistics object with counts and breakdowns
+ *
+ * @example
+ * ```typescript
+ * const stats = getPendingResourceStats(pendingResources);
+ * console.log(`${stats.totalCount} pending resources`);
+ * console.log(`Types: ${Object.keys(stats.byType).join(', ')}`);
+ * ```
+ *
+ * @public
+ */
+export function getPendingResourceStats(pendingResources) {
+    const stats = {
+        totalCount: pendingResources.size,
+        byType: {},
+        resourceIds: Array.from(pendingResources.keys()).sort()
+    };
+    pendingResources.forEach((resource) => {
+        if (resource.resourceTypeName) {
+            stats.byType[resource.resourceTypeName] = (stats.byType[resource.resourceTypeName] || 0) + 1;
+        }
+    });
+    return stats;
+}
+/**
+ * Validates that all keys in a pending resources map are properly formatted as full resource IDs.
+ * This is a diagnostic function to ensure the pending resource key invariant is maintained.
+ *
+ * @param pendingResources - Map of pending resources to validate
+ * @returns Result indicating whether all keys are valid full resource IDs, or details about any issues found
+ *
+ * @example
+ * ```typescript
+ * const validation = validatePendingResourceKeys(pendingResources);
+ * if (validation.isFailure()) {
+ *   console.error('Pending resource key validation failed:', validation.message);
+ * }
+ * ```
+ *
+ * @public
+ */
+export function validatePendingResourceKeys(pendingResources) {
+    const issues = [];
+    pendingResources.forEach((resource, key) => {
+        // Check for empty keys
+        if (!key || key.trim().length === 0) {
+            issues.push('Found empty resource ID key');
+            return;
+        }
+        // Check for temporary IDs (should not be in pending resources)
+        if (key.startsWith('new-resource-')) {
+            issues.push(`Found temporary ID key: ${key}`);
+        }
+        // Check for minimum structure (at least one dot)
+        if (!key.includes('.')) {
+            issues.push(`Resource ID '${key}' appears to be a leaf ID rather than a full resource ID`);
+        }
+        // Check for trailing dots
+        if (key.endsWith('.')) {
+            issues.push(`Resource ID '${key}' ends with a dot`);
+        }
+        // Check for leading dots
+        if (key.startsWith('.')) {
+            issues.push(`Resource ID '${key}' starts with a dot`);
+        }
+        // Check for double dots
+        if (key.includes('..')) {
+            issues.push(`Resource ID '${key}' contains consecutive dots`);
+        }
+    });
+    if (issues.length > 0) {
+        return fail(`Pending resource key validation failed: ${issues.join('; ')}`);
+    }
+    return succeed(undefined);
+}
+//# sourceMappingURL=resourceSelectors.js.map

package/lib-commonjs/components/orchestrator/ResourceOrchestrator.js

@@ -315,10 +315,12 @@ const ResourceOrchestrator = ({ children, initialConfiguration, qualifierTypeFac
         clearResourceEdits: resolutionData.actions.clearEdits,
         // Edits applied through unified applyPendingResources
         discardResourceEdits: resolutionData.actions.discardEdits,
-        // Resource creation actions
+        // Resource creation actions (enhanced with atomic API)
+        createPendingResource: resolutionData.actions.createPendingResource,
         startNewResource: resolutionData.actions.startNewResource,
         updateNewResourceId: resolutionData.actions.updateNewResourceId,
         selectResourceType: resolutionData.actions.selectResourceType,
+        updateNewResourceJson: resolutionData.actions.updateNewResourceJson,
         saveNewResourceAsPending: resolutionData.actions.saveNewResourceAsPending,
         cancelNewResource: resolutionData.actions.cancelNewResource,
         removePendingResource: resolutionData.actions.removePendingResource,