@ikas/component-cli 0.103.0 → 0.104.0

package/dist/commands/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/commands/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAk8BpC,wBAAgB,mBAAmB,IAAI,OAAO,CAwH7C"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/commands/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAg3CpC,wBAAgB,mBAAmB,IAAI,OAAO,CA0K7C"}

package/dist/commands/config.js

@@ -1,7 +1,7 @@
 import { Command } from "commander";
 import * as fs from "fs";
 import * as path from "path";
-import { PROP_TYPES, toPascalCase, toKebabCase, generateTypesFile, generateGlobalTypesFile, generateComponentFile, generateStylesFile, generateProjectId, generateComponentId, updateBarrelExport, findPropGroup, collectPropGroupIds, } from "../utils/component-helpers.js";
+import { PROP_TYPES, toPascalCase, toKebabCase, generateTypesFile, generateGlobalTypesFile, generateComponentFile, generateStylesFile, generateProjectId, generateComponentId, generateUniqueId, updateBarrelExport, findPropGroup, collectPropGroupIds, } from "../utils/component-helpers.js";
 function loadConfig() {
     const configPath = path.resolve(process.cwd(), "ikas.config.json");
     if (!fs.existsSync(configPath)) {
@@ -53,7 +53,7 @@ function camelCaseToDisplayName(name) {
  * Parse and validate the --props JSON flag for add-component.
  * Returns validated ComponentProp[] or exits with error.
  */
-function parsePropsFlag(propsJson) {
+function parsePropsFlag(propsJson, config) {
     let rawProps;
     try {
         rawProps = JSON.parse(propsJson);
@@ -135,10 +135,22 @@ function parsePropsFlag(propsJson) {
             if (!r.enumTypeId || typeof r.enumTypeId !== "string") {
                 console.log(JSON.stringify({
                     success: false,
-                    error: `Prop "${r.name}" has type ENUM but is missing required "enumTypeId" field.`,
+                    error: `Prop "${r.name}" has type ENUM but is missing required "enumTypeId" field. Create one with: config add-enum`,
                 }));
                 process.exit(1);
             }
+            // Validate enum type exists (skip library types)
+            if (config && typeof r.enumTypeId === "string" && !r.enumTypeId.startsWith("@ikas/")) {
+                const customTypes = config.customTypes || [];
+                const enumExists = customTypes.some((t) => t.id === r.enumTypeId && t.type === "enum");
+                if (!enumExists) {
+                    console.log(JSON.stringify({
+                        success: false,
+                        error: `Enum type "${r.enumTypeId}" not found for prop "${r.name}". Create it first with: config add-enum --name "MyEnum" --options '{"Label":"value"}'`,
+                    }));
+                    process.exit(1);
+                }
+            }
         }
         const prop = {
             name: r.name,
@@ -151,12 +163,21 @@ function parsePropsFlag(propsJson) {
             ...(r.defaultValue !== undefined
                 ? { defaultValue: r.defaultValue }
                 : {}),
+            ...(typeof r.groupId === "string" && r.groupId
+                ? { groupId: r.groupId }
+                : {}),
             ...(propType === "TYPE" && typeof r.typeId === "string"
                 ? { typeId: r.typeId }
                 : {}),
             ...(propType === "ENUM" && typeof r.enumTypeId === "string"
                 ? { enumTypeId: r.enumTypeId }
                 : {}),
+            ...((propType === "COMPONENT" || propType === "COMPONENT_LIST") && r.filteredComponentIds && Array.isArray(r.filteredComponentIds)
+                ? { filteredComponentIds: r.filteredComponentIds }
+                : {}),
+            ...((propType === "COMPONENT" || propType === "COMPONENT_LIST") && r.privateVarMap && typeof r.privateVarMap === "object"
+                ? { privateVarMap: r.privateVarMap }
+                : {}),
         };
         props.push(prop);
     }
@@ -194,8 +215,22 @@ function addComponent(name, options) {
     fs.mkdirSync(componentDir, { recursive: true });
     // Parse --props if provided, otherwise empty
     const props = options.props
-        ? parsePropsFlag(options.props)
+        ? parsePropsFlag(options.props, config)
         : [];
+    // Auto-create prop groups from groupId references in props
+    const referencedGroupIds = new Set();
+    for (const prop of props) {
+        if (prop.groupId) {
+            referencedGroupIds.add(prop.groupId);
+        }
+    }
+    let propGroups;
+    if (referencedGroupIds.size > 0) {
+        propGroups = Array.from(referencedGroupIds).map((groupId) => ({
+            id: groupId,
+            name: camelCaseToDisplayName(groupId),
+        }));
+    }
     fs.writeFileSync(path.join(componentDir, "types.ts"), generateTypesFile(pascalName, props, componentType, null, config.customTypes));
     fs.writeFileSync(path.join(componentDir, "index.tsx"), generateComponentFile(pascalName, props, componentType));
     fs.writeFileSync(path.join(componentDir, "styles.css"), generateStylesFile(pascalName, componentType));
@@ -209,6 +244,7 @@ function addComponent(name, options) {
         ...(options.isHeader ? { isHeader: true } : {}),
         ...(options.isFooter ? { isFooter: true } : {}),
         props,
+        ...(propGroups ? { propGroups } : {}),
     };
     config.components.push(newComponent);
     saveConfig(configPath, config);
@@ -278,10 +314,22 @@ function addProp(componentName, options) {
     if (propType === "ENUM" && !options.enumTypeId) {
         console.log(JSON.stringify({
             success: false,
-            error: `ENUM props require --enumTypeId. Run "config list-types" to see available enum types.`,
+            error: `ENUM props require --enumTypeId. Run "config add-enum" to create one, or "config list-types" to see available types.`,
         }));
         process.exit(1);
     }
+    // Validate that enumTypeId references an existing enum type
+    if (propType === "ENUM" && options.enumTypeId && !options.enumTypeId.startsWith("@ikas/")) {
+        const customTypes = config.customTypes || [];
+        const enumExists = customTypes.some((t) => t.id === options.enumTypeId && t.type === "enum");
+        if (!enumExists) {
+            console.log(JSON.stringify({
+                success: false,
+                error: `Enum type "${options.enumTypeId}" not found. Create it first with: config add-enum --name "MyEnum" --options '{"Label":"value"}'`,
+            }));
+            process.exit(1);
+        }
+    }
     // Validate group reference
     if (options.group) {
         if (!component.propGroups || component.propGroups.length === 0) {
@@ -300,6 +348,36 @@ function addProp(componentName, options) {
             process.exit(1);
         }
     }
+    // Parse filteredComponentIds JSON for COMPONENT/COMPONENT_LIST
+    let parsedFilteredIds;
+    if (options.filteredComponentIds && (propType === "COMPONENT" || propType === "COMPONENT_LIST")) {
+        try {
+            parsedFilteredIds = JSON.parse(options.filteredComponentIds);
+            if (!Array.isArray(parsedFilteredIds)) {
+                console.log(JSON.stringify({ success: false, error: "--filteredComponentIds must be a JSON array of strings." }));
+                process.exit(1);
+            }
+        }
+        catch {
+            console.log(JSON.stringify({ success: false, error: `Invalid --filteredComponentIds JSON: ${options.filteredComponentIds}` }));
+            process.exit(1);
+        }
+    }
+    // Parse privateVarMap JSON for COMPONENT/COMPONENT_LIST
+    let parsedPrivateVarMap;
+    if (options.privateVarMap && (propType === "COMPONENT" || propType === "COMPONENT_LIST")) {
+        try {
+            parsedPrivateVarMap = JSON.parse(options.privateVarMap);
+            if (typeof parsedPrivateVarMap !== "object" || Array.isArray(parsedPrivateVarMap)) {
+                console.log(JSON.stringify({ success: false, error: "--privateVarMap must be a JSON object mapping keys to {id, typeId}." }));
+                process.exit(1);
+            }
+        }
+        catch {
+            console.log(JSON.stringify({ success: false, error: `Invalid --privateVarMap JSON: ${options.privateVarMap}` }));
+            process.exit(1);
+        }
+    }
     const newProp = {
         name: options.name,
         displayName: options.displayName,
@@ -312,6 +390,8 @@ function addProp(componentName, options) {
         ...(options.group ? { groupId: options.group } : {}),
         ...(options.typeId ? { typeId: options.typeId } : {}),
         ...(options.enumTypeId ? { enumTypeId: options.enumTypeId } : {}),
+        ...(parsedFilteredIds ? { filteredComponentIds: parsedFilteredIds } : {}),
+        ...(parsedPrivateVarMap ? { privateVarMap: parsedPrivateVarMap } : {}),
     };
     component.props.push(newProp);
     saveConfig(configPath, config);
@@ -328,6 +408,8 @@ function addProp(componentName, options) {
             required: newProp.required,
             ...(newProp.groupId ? { groupId: newProp.groupId } : {}),
             ...(newProp.enumTypeId ? { enumTypeId: newProp.enumTypeId } : {}),
+            ...(newProp.filteredComponentIds ? { filteredComponentIds: newProp.filteredComponentIds } : {}),
+            ...(newProp.privateVarMap ? { privateVarMap: newProp.privateVarMap } : {}),
         },
     }));
 }
@@ -422,6 +504,44 @@ function updateProp(componentName, options) {
             prop.enumTypeId = options.enumTypeId;
         }
     }
+    if (options.filteredComponentIds !== undefined) {
+        if (options.filteredComponentIds === "" || options.filteredComponentIds === "none") {
+            delete prop.filteredComponentIds;
+        }
+        else {
+            try {
+                const parsed = JSON.parse(options.filteredComponentIds);
+                if (!Array.isArray(parsed)) {
+                    console.log(JSON.stringify({ success: false, error: "--filteredComponentIds must be a JSON array of strings." }));
+                    process.exit(1);
+                }
+                prop.filteredComponentIds = parsed;
+            }
+            catch {
+                console.log(JSON.stringify({ success: false, error: `Invalid --filteredComponentIds JSON: ${options.filteredComponentIds}` }));
+                process.exit(1);
+            }
+        }
+    }
+    if (options.privateVarMap !== undefined) {
+        if (options.privateVarMap === "" || options.privateVarMap === "none") {
+            delete prop.privateVarMap;
+        }
+        else {
+            try {
+                const parsed = JSON.parse(options.privateVarMap);
+                if (typeof parsed !== "object" || Array.isArray(parsed)) {
+                    console.log(JSON.stringify({ success: false, error: "--privateVarMap must be a JSON object mapping keys to {id, typeId}." }));
+                    process.exit(1);
+                }
+                prop.privateVarMap = parsed;
+            }
+            catch {
+                console.log(JSON.stringify({ success: false, error: `Invalid --privateVarMap JSON: ${options.privateVarMap}` }));
+                process.exit(1);
+            }
+        }
+    }
     saveConfig(configPath, config);
     // Regenerate types.ts and global types
     regenerateTypes(component, undefined, config);
@@ -437,6 +557,8 @@ function updateProp(componentName, options) {
             ...(prop.groupId ? { groupId: prop.groupId } : {}),
             ...(prop.typeId ? { typeId: prop.typeId } : {}),
             ...(prop.enumTypeId ? { enumTypeId: prop.enumTypeId } : {}),
+            ...(prop.filteredComponentIds ? { filteredComponentIds: prop.filteredComponentIds } : {}),
+            ...(prop.privateVarMap ? { privateVarMap: prop.privateVarMap } : {}),
         },
     }));
 }
@@ -643,6 +765,41 @@ function removePropGroup(componentName, options) {
         remainingPropGroups: component.propGroups.map(g => g.id),
     }));
 }
+function updateComponent(options) {
+    const { config, configPath } = loadConfig();
+    const component = findComponent(config, options.name);
+    if (!component) {
+        console.log(JSON.stringify({
+            success: false,
+            error: `Component "${options.name}" not found. Available: ${getComponentNames(config).join(", ")}`,
+        }));
+        process.exit(1);
+    }
+    if (options.isHeader !== undefined) {
+        if (options.isHeader) {
+            component.isHeader = true;
+        }
+        else {
+            delete component.isHeader;
+        }
+    }
+    if (options.isFooter !== undefined) {
+        if (options.isFooter) {
+            component.isFooter = true;
+        }
+        else {
+            delete component.isFooter;
+        }
+    }
+    saveConfig(configPath, config);
+    console.log(JSON.stringify({
+        success: true,
+        componentName: component.name,
+        type: component.type ?? "component",
+        ...(component.isHeader ? { isHeader: true } : {}),
+        ...(component.isFooter ? { isFooter: true } : {}),
+    }));
+}
 function listComponents() {
     const { config } = loadConfig();
     const components = config.components.map((c) => ({
@@ -670,6 +827,184 @@ function listComponents() {
         components,
     }));
 }
+// --- Enum CRUD ---
+function addEnum(options) {
+    const { config, configPath } = loadConfig();
+    // Validate name
+    if (!options.name || typeof options.name !== "string" || !options.name.trim()) {
+        console.log(JSON.stringify({ success: false, error: "Enum name is required." }));
+        process.exit(1);
+    }
+    const enumName = options.name.trim();
+    // Check for name collision (PascalCase comparison since generated TS types are PascalCase)
+    if (!config.customTypes)
+        config.customTypes = [];
+    const pascalName = toPascalCase(enumName);
+    const existing = config.customTypes.find((t) => t.type === "enum" && toPascalCase(t.name) === pascalName);
+    if (existing) {
+        console.log(JSON.stringify({
+            success: false,
+            error: `Enum "${enumName}" already exists (ID: ${existing.id}).`,
+        }));
+        process.exit(1);
+    }
+    // Parse and validate options JSON
+    let enumOptions;
+    try {
+        enumOptions = JSON.parse(options.options);
+    }
+    catch {
+        console.log(JSON.stringify({
+            success: false,
+            error: `Invalid --options JSON: ${options.options}`,
+        }));
+        process.exit(1);
+    }
+    if (typeof enumOptions !== "object" ||
+        Array.isArray(enumOptions) ||
+        Object.keys(enumOptions).length === 0) {
+        console.log(JSON.stringify({
+            success: false,
+            error: 'Options must be a non-empty JSON object, e.g. \'{"Small":"sm","Medium":"md","Large":"lg"}\'.',
+        }));
+        process.exit(1);
+    }
+    const enumId = generateUniqueId();
+    config.customTypes.push({
+        id: enumId,
+        name: enumName,
+        type: "enum",
+        enumOptions,
+        isDynamic: false,
+    });
+    saveConfig(configPath, config);
+    // Regenerate global types and all component types
+    regenerateGlobalTypes(config);
+    for (const component of config.components) {
+        regenerateTypes(component, undefined, config);
+    }
+    console.log(JSON.stringify({
+        success: true,
+        enumId,
+        enumName,
+        enumOptions,
+    }));
+}
+function updateEnum(options) {
+    const { config, configPath } = loadConfig();
+    if (!config.customTypes)
+        config.customTypes = [];
+    const enumIndex = config.customTypes.findIndex((t) => t.id === options.id && t.type === "enum");
+    if (enumIndex === -1) {
+        console.log(JSON.stringify({
+            success: false,
+            error: `Enum with ID "${options.id}" not found.`,
+        }));
+        process.exit(1);
+    }
+    const enumType = config.customTypes[enumIndex];
+    if (options.name !== undefined) {
+        const pascalName = toPascalCase(options.name);
+        const collision = config.customTypes.find((t) => t.type === "enum" &&
+            t.id !== options.id &&
+            toPascalCase(t.name) === pascalName);
+        if (collision) {
+            console.log(JSON.stringify({
+                success: false,
+                error: `Enum name "${options.name}" conflicts with existing enum (ID: ${collision.id}).`,
+            }));
+            process.exit(1);
+        }
+        enumType.name = options.name;
+    }
+    if (options.options !== undefined) {
+        let enumOptions;
+        try {
+            enumOptions = JSON.parse(options.options);
+        }
+        catch {
+            console.log(JSON.stringify({
+                success: false,
+                error: `Invalid --options JSON: ${options.options}`,
+            }));
+            process.exit(1);
+        }
+        if (typeof enumOptions !== "object" ||
+            Array.isArray(enumOptions) ||
+            Object.keys(enumOptions).length === 0) {
+            console.log(JSON.stringify({
+                success: false,
+                error: 'Options must be a non-empty JSON object.',
+            }));
+            process.exit(1);
+        }
+        enumType.enumOptions = enumOptions;
+    }
+    saveConfig(configPath, config);
+    // Regenerate global types and all component types
+    regenerateGlobalTypes(config);
+    for (const component of config.components) {
+        regenerateTypes(component, undefined, config);
+    }
+    console.log(JSON.stringify({
+        success: true,
+        enumId: enumType.id,
+        enumName: enumType.name,
+        enumOptions: enumType.enumOptions,
+    }));
+}
+function removeEnum(options) {
+    const { config, configPath } = loadConfig();
+    if (!config.customTypes)
+        config.customTypes = [];
+    const enumIndex = config.customTypes.findIndex((t) => t.id === options.id && t.type === "enum");
+    if (enumIndex === -1) {
+        console.log(JSON.stringify({
+            success: false,
+            error: `Enum with ID "${options.id}" not found.`,
+        }));
+        process.exit(1);
+    }
+    // Check if any component prop references this enum
+    for (const component of config.components) {
+        for (const prop of component.props) {
+            if (prop.enumTypeId === options.id) {
+                console.log(JSON.stringify({
+                    success: false,
+                    error: `Cannot remove enum "${config.customTypes[enumIndex].name}": prop "${prop.name}" on component "${component.name}" references it. Remove or update the prop first.`,
+                }));
+                process.exit(1);
+            }
+        }
+    }
+    const removed = config.customTypes.splice(enumIndex, 1)[0];
+    saveConfig(configPath, config);
+    // Regenerate global types and all component types
+    regenerateGlobalTypes(config);
+    for (const component of config.components) {
+        regenerateTypes(component, undefined, config);
+    }
+    console.log(JSON.stringify({
+        success: true,
+        removedEnumId: removed.id,
+        removedEnumName: removed.name,
+    }));
+}
+function listEnums() {
+    const { config } = loadConfig();
+    const enums = (config.customTypes || [])
+        .filter((t) => t.type === "enum")
+        .map((t) => ({
+        id: t.id,
+        name: t.name,
+        enumOptions: t.enumOptions,
+    }));
+    console.log(JSON.stringify({
+        success: true,
+        enumCount: enums.length,
+        enums,
+    }));
+}
 // --- Command registration ---
 export function createConfigCommand() {
     const config = new Command("config")
@@ -698,6 +1033,8 @@ export function createConfigCommand() {
         .option("--group <groupId>", "Assign prop to a prop group")
         .option("--typeId <typeId>", "Type ID for TYPE props (required when type is TYPE)")
         .option("--enumTypeId <enumTypeId>", "Enum type ID for ENUM props (required when type is ENUM)")
+        .option("--filteredComponentIds <json>", "JSON array of component IDs to restrict selection (for COMPONENT/COMPONENT_LIST)")
+        .option("--privateVarMap <json>", 'JSON object mapping variable keys to {id, typeId} (for COMPONENT/COMPONENT_LIST)')
         .action((options) => {
         addProp(options.component, options);
     });
@@ -714,6 +1051,8 @@ export function createConfigCommand() {
         .option("--group <groupId>", "Move prop to a group (use 'none' to ungroup)")
         .option("--typeId <typeId>", "Type ID for TYPE props (use 'none' to clear)")
         .option("--enumTypeId <enumTypeId>", "Enum type ID for ENUM props (use 'none' to clear)")
+        .option("--filteredComponentIds <json>", "JSON array of component IDs (use 'none' to clear)")
+        .option("--privateVarMap <json>", "JSON object mapping variable keys to {id, typeId} (use 'none' to clear)")
         .action((options) => {
         updateProp(options.component, options);
     });
@@ -725,6 +1064,17 @@ export function createConfigCommand() {
         .action((options) => {
         removeProp(options.component, options);
     });
+    config
+        .command("update-component")
+        .description("Update a component's metadata (isHeader, isFooter)")
+        .requiredOption("--name <name>", "Component name")
+        .option("--isHeader", "Mark as store header")
+        .option("--no-isHeader", "Unmark as store header")
+        .option("--isFooter", "Mark as store footer")
+        .option("--no-isFooter", "Unmark as store footer")
+        .action((options) => {
+        updateComponent(options);
+    });
     config
         .command("remove-component")
         .description("Remove a component from the project (deletes files)")
@@ -774,6 +1124,36 @@ export function createConfigCommand() {
         .action(async (options) => {
         await listTypes(options.componentType);
     });
+    config
+        .command("add-enum")
+        .description("Create a custom enum type (offline, no editor needed)")
+        .requiredOption("--name <name>", "Enum name (e.g. Size, AspectRatio)")
+        .requiredOption("--options <json>", 'JSON object of label→value pairs, e.g. \'{"Small":"sm","Medium":"md","Large":"lg"}\'')
+        .action((options) => {
+        addEnum(options);
+    });
+    config
+        .command("update-enum")
+        .description("Update a custom enum type")
+        .requiredOption("--id <id>", "Enum ID to update")
+        .option("--name <name>", "New enum name")
+        .option("--options <json>", "New JSON object of label→value pairs")
+        .action((options) => {
+        updateEnum(options);
+    });
+    config
+        .command("remove-enum")
+        .description("Remove a custom enum type (fails if any prop references it)")
+        .requiredOption("--id <id>", "Enum ID to remove")
+        .action((options) => {
+        removeEnum(options);
+    });
+    config
+        .command("list-enums")
+        .description("List all custom enum types defined in this project")
+        .action(() => {
+        listEnums();
+    });
     return config;
 }
 async function listTypes(componentType) {