sb-mig 5.5.4-beta.1 → 5.6.0-beta.2

package/dist/utils/array-utils.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Array utility functions
+ */
+/**
+ * Get unique values from an array
+ * Uses Set for O(n) deduplication
+ *
+ * @param array - The array to deduplicate
+ * @returns A new array with only unique values
+ *
+ * @example
+ * uniqueValuesFrom([1, 2, 2, 3, 3, 3]) // => [1, 2, 3]
+ * uniqueValuesFrom(['a', 'b', 'a']) // => ['a', 'b']
+ */
+export declare const uniqueValuesFrom: <T>(array: T[]) => T[];
+/**
+ * @deprecated Use uniqueValuesFrom instead
+ * Alias for backwards compatibility
+ */
+export declare const _uniqueValuesFrom: <T>(array: T[]) => T[];

package/dist/utils/array-utils.js

@@ -0,0 +1,20 @@
+/**
+ * Array utility functions
+ */
+/**
+ * Get unique values from an array
+ * Uses Set for O(n) deduplication
+ *
+ * @param array - The array to deduplicate
+ * @returns A new array with only unique values
+ *
+ * @example
+ * uniqueValuesFrom([1, 2, 2, 3, 3, 3]) // => [1, 2, 3]
+ * uniqueValuesFrom(['a', 'b', 'a']) // => ['a', 'b']
+ */
+export const uniqueValuesFrom = (array) => [...new Set(array)];
+/**
+ * @deprecated Use uniqueValuesFrom instead
+ * Alias for backwards compatibility
+ */
+export const _uniqueValuesFrom = uniqueValuesFrom;

package/dist/utils/async-utils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Async utility functions
+ */
+/**
+ * Delay execution for a specified time
+ *
+ * @param time - Time to delay in milliseconds
+ * @returns Promise that resolves after the delay
+ *
+ * @example
+ * await delay(1000); // Wait 1 second
+ */
+export declare const delay: (time: number) => Promise<void>;

package/dist/utils/async-utils.js

@@ -0,0 +1,13 @@
+/**
+ * Async utility functions
+ */
+/**
+ * Delay execution for a specified time
+ *
+ * @param time - Time to delay in milliseconds
+ * @returns Promise that resolves after the delay
+ *
+ * @example
+ * await delay(1000); // Wait 1 second
+ */
+export const delay = (time) => new Promise((resolve) => setTimeout(resolve, time));

package/dist/utils/date-utils.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Date utility functions
+ */
+/**
+ * Generate a datestamp string from a Date object
+ * Format: YYYY-M-D_H-M (no zero-padding)
+ *
+ * @param datestamp - The Date object to format
+ * @returns Formatted date string
+ *
+ * @example
+ * generateDatestamp(new Date('2024-03-15T10:30:00')) // => '2024-3-15_10-30'
+ */
+export declare const generateDatestamp: (datestamp: Date) => string;

package/dist/utils/date-utils.js

@@ -0,0 +1,21 @@
+/**
+ * Date utility functions
+ */
+/**
+ * Generate a datestamp string from a Date object
+ * Format: YYYY-M-D_H-M (no zero-padding)
+ *
+ * @param datestamp - The Date object to format
+ * @returns Formatted date string
+ *
+ * @example
+ * generateDatestamp(new Date('2024-03-15T10:30:00')) // => '2024-3-15_10-30'
+ */
+export const generateDatestamp = (datestamp) => {
+    const year = datestamp.getFullYear();
+    const month = datestamp.getMonth() + 1;
+    const day = datestamp.getDate();
+    const hours = datestamp.getHours();
+    const minutes = datestamp.getMinutes();
+    return `${year}-${month}-${day}_${hours}-${minutes}`;
+};

package/dist/utils/files.d.ts

@@ -1,4 +1,39 @@
 import type { RequestBaseConfig } from "../api/utils/request.js";
+/**
+ * Asynchronously load a file using dynamic import
+ * Returns the default export of the module
+ *
+ * @param data - Object containing the file path
+ * @returns The default export of the imported module
+ */
+export declare const getFileContent: (data: {
+    file: string;
+}) => any;
+/**
+ * Synchronously load a file using require
+ * Handles both CommonJS and ES modules with default exports
+ *
+ * @param data - Object containing the file path
+ * @returns The file content (default export if available)
+ */
+export declare const getFileContentWithRequire: (data: {
+    file: string;
+}) => any;
+/**
+ * Load multiple files using require
+ *
+ * @param data - Object containing array of file paths
+ * @returns Array of file contents
+ */
+export declare const getFilesContentWithRequire: (data: {
+    files: string[];
+}) => any[];
+/**
+ * Read and parse the package.json from current working directory
+ *
+ * @returns Parsed package.json object
+ */
+export declare const getPackageJson: () => any;
 export declare const isDirectoryExists: (path: string) => boolean;
 export declare const createDir: (dirPath: string) => Promise<void>;
 export declare const createJsonFile: (content: string, pathWithFilename: string) => Promise<void>;

package/dist/utils/files.js

@@ -1,11 +1,66 @@
 import * as fs from "fs";
 import { writeFile } from "fs";
+import { createRequire } from "module";
 import path from "path";
 import pkg from "ncp";
+import { generateDatestamp } from "./date-utils.js";
 import Logger from "./logger.js";
-import { getFileContentWithRequire } from "./main.js";
-import { generateDatestamp } from "./others.js";
 const { ncp } = pkg;
+// ============================================================================
+// File Content Loading
+// ============================================================================
+/**
+ * Asynchronously load a file using dynamic import
+ * Returns the default export of the module
+ *
+ * @param data - Object containing the file path
+ * @returns The default export of the imported module
+ */
+export const getFileContent = (data) => {
+    return import(data.file)
+        .then((res) => {
+        return res.default;
+    })
+        .catch((err) => {
+        console.log(err);
+        console.log("Cannot find requested file.");
+    });
+};
+/**
+ * Synchronously load a file using require
+ * Handles both CommonJS and ES modules with default exports
+ *
+ * @param data - Object containing the file path
+ * @returns The file content (default export if available)
+ */
+export const getFileContentWithRequire = (data) => {
+    const require = createRequire(import.meta.url);
+    const fileContent = require(data.file);
+    if (fileContent.default) {
+        return fileContent.default;
+    }
+    return fileContent;
+};
+/**
+ * Load multiple files using require
+ *
+ * @param data - Object containing array of file paths
+ * @returns Array of file contents
+ */
+export const getFilesContentWithRequire = (data) => {
+    return data.files.map((file) => getFileContentWithRequire({ file }));
+};
+/**
+ * Read and parse the package.json from current working directory
+ *
+ * @returns Parsed package.json object
+ */
+export const getPackageJson = () => {
+    const packageJsonPath = path.join(process.cwd(), "package.json");
+    const packageJsonContent = fs.readFileSync(packageJsonPath, "utf-8");
+    const packageJson = JSON.parse(packageJsonContent);
+    return packageJson;
+};
 export const isDirectoryExists = (path) => fs.existsSync(path);
 export const createDir = async (dirPath) => {
     await fs.promises.mkdir(`${process.cwd()}/${dirPath}`, {

package/dist/utils/main.d.ts

@@ -1,18 +1,8 @@
-export declare const prop: (k: any) => (o: any) => any;
-export declare const pipe: (...fns: any[]) => (x: any) => any;
-export declare const unpackElements: (input: string[]) => string[];
-export declare const unpackOne: (input: string[]) => string | undefined;
-export declare const getFileContent: (data: {
-    file: string;
-}) => any;
-export declare const getFileContentWithRequire: (data: {
-    file: string;
-}) => any;
-export declare const getFilesContentWithRequire: (data: {
-    files: string[];
-}) => any[];
-export declare const isObjectEmpty: (obj: any) => boolean;
-export declare const delay: (time: number) => Promise<unknown>;
-export declare const isItFactory: <T>(flags: any, rules: any, whitelist: string[]) => (type: T) => boolean;
-export declare const getPackageJson: () => any;
-export declare const extractFields: (data: any, filter: any) => any;
+/**
+ * Re-exports for backwards compatibility
+ * Functions have been moved to their proper modules
+ */
+export { prop, pipe, unpackElements, unpackOne, isItFactory, } from "../cli/utils/cli-utils.js";
+export { isObjectEmpty, extractFields } from "./object-utils.js";
+export { getFileContent, getFileContentWithRequire, getFilesContentWithRequire, getPackageJson, } from "./files.js";
+export { delay } from "./async-utils.js";

package/dist/utils/main.js

@@ -1,104 +1,12 @@
-import fs from "fs";
-import { createRequire } from "module";
-import path from "path";
-export const prop = (k) => (o) => o[k];
-export const pipe = (...fns) => (x) => [...fns].reduce((acc, f) => f(acc), x);
-export const unpackElements = (input) => {
-    const [_1, _2, ...elementsForUse] = input;
-    return elementsForUse;
-};
-export const unpackOne = (input) => {
-    const [_1, _2, elementForUse] = input;
-    return elementForUse;
-};
-export const getFileContent = (data) => {
-    return import(data.file)
-        .then((res) => {
-        return res.default;
-    })
-        .catch((err) => {
-        console.log(err);
-        console.log("Cannot find requested file.");
-    });
-};
-export const getFileContentWithRequire = (data) => {
-    const require = createRequire(import.meta.url);
-    const fileContent = require(data.file);
-    if (fileContent.default) {
-        return fileContent.default;
-    }
-    return fileContent;
-};
-export const getFilesContentWithRequire = (data) => {
-    return data.files.map((file) => getFileContentWithRequire({ file }));
-};
-export const isObjectEmpty = (obj) => {
-    if (obj) {
-        return Object.keys(obj).length === 0 && obj.constructor === Object;
-    }
-    else {
-        return true;
-    }
-};
-export const delay = (time) => new Promise((resolve) => setTimeout(resolve, time));
-export const isItFactory = (flags, rules, whitelist) => {
-    return (type) => {
-        const rulesCopy = [...rules[type]];
-        const flagsKeys = Object.keys(flags);
-        const temp = flagsKeys.map((flag) => {
-            if (whitelist.includes(flag)) {
-                return true;
-            }
-            if (rulesCopy.includes(flag)) {
-                rulesCopy.splice(rulesCopy.indexOf(flag), 1);
-                return true;
-            }
-            else {
-                return false;
-            }
-        });
-        if (rulesCopy.length > 0) {
-            return false;
-        }
-        else {
-            return temp.every((el) => el === true);
-        }
-    };
-};
-export const getPackageJson = () => {
-    const packageJsonPath = path.join(process.cwd(), "package.json");
-    // Read the file content as a string
-    const packageJsonContent = fs.readFileSync(packageJsonPath, "utf-8");
-    // Parse the file content as a JSON object
-    const packageJson = JSON.parse(packageJsonContent);
-    return packageJson;
-};
-export const extractFields = (data, filter) => {
-    const result = {};
-    for (const key in filter) {
-        if (filter[key] === true) {
-            result[key] = data[key];
-        }
-        else if (typeof filter[key] === "object") {
-            result[key] = extractFields(data[key], filter[key]);
-        }
-    }
-    return result;
-};
-// export const generateMetadata = (args: any) => {
-//     const packageJson = getPackageJson();
-//
-//     const contentHubName = packageJson.name;
-//     const contentHubLatestVersion = packageJson.version;
-//
-//     const backpackVersionInContentHub =
-//         packageJson.dependencies['@ef-global/backpack'];
-//
-//     return {
-//         metadata: {
-//             contentHubName,
-//             contentHubLatestVersion,
-//             backpackVersionInContentHub,
-//         },
-//     };
-// };
+/**
+ * Re-exports for backwards compatibility
+ * Functions have been moved to their proper modules
+ */
+// CLI utils - now in src/cli/utils/cli-utils.ts
+export { prop, pipe, unpackElements, unpackOne, isItFactory, } from "../cli/utils/cli-utils.js";
+// Object utils - now in src/utils/object-utils.ts
+export { isObjectEmpty, extractFields } from "./object-utils.js";
+// File loading utils - now in src/utils/files.ts
+export { getFileContent, getFileContentWithRequire, getFilesContentWithRequire, getPackageJson, } from "./files.js";
+// Async utils - now in src/utils/async-utils.ts
+export { delay } from "./async-utils.js";

package/dist/utils/migrations.d.ts

@@ -1,5 +1,12 @@
-type MigrationNames = "transitionsOnEnter" | "otherMigration" | "cardsMigration" | "hideToVisibility";
-type VersionMapping = Record<string, MigrationNames[]>;
+/**
+ * Known migration names (can be extended as new migrations are added)
+ */
+export type MigrationNames = "transitionsOnEnter" | "otherMigration" | "cardsMigration" | "hideToVisibility";
+/**
+ * Version mapping - maps semver versions to arrays of migration names
+ * Uses string[] to allow flexibility for new migrations
+ */
+export type VersionMapping = Record<string, string[]>;
 export declare const preselectMigrations: (currentVersion: string, installedVersion: string, versionMapping: VersionMapping, alreadyApplied?: {
     story: string[];
     preset: string[];
@@ -8,4 +15,3 @@ export declare const preselectMigrations: (currentVersion: string, installedVers
     preset: never[];
 };
 export declare const modifyOrCreateAppliedMigrationsFile: (migrationApplied: string, itemType: "story" | "preset") => Promise<void>;
-export {};

package/dist/utils/object-utils.d.ts

@@ -0,0 +1,46 @@
+/**
+ * General object utility functions
+ */
+/**
+ * Filter out null and undefined values from an object
+ * Keeps all properties that have defined values (including falsy values like 0, '', false)
+ *
+ * @param params - The object to filter
+ * @returns A new object with only non-nullish values
+ *
+ * @example
+ * notNullish({ a: 1, b: null, c: undefined, d: 0 }) // => { a: 1, d: 0 }
+ */
+export declare const notNullish: <T extends Record<string, any>>(params: T) => T;
+/**
+ * Check if an object is empty (has no own properties)
+ * Returns true for null, undefined, and empty objects {}
+ * Returns false for arrays (even empty ones) and objects with properties
+ *
+ * @param obj - The object to check
+ * @returns true if the object is empty, null, or undefined
+ *
+ * @example
+ * isObjectEmpty({}) // => true
+ * isObjectEmpty(null) // => true
+ * isObjectEmpty({ name: 'test' }) // => false
+ * isObjectEmpty([]) // => false (arrays are not plain objects)
+ */
+export declare const isObjectEmpty: (obj: any) => boolean;
+/**
+ * Extract specific fields from an object based on a filter object
+ * Supports nested object extraction
+ *
+ * @param data - The source object to extract fields from
+ * @param filter - An object where true means include the field, nested objects for nested extraction
+ * @returns A new object containing only the specified fields
+ *
+ * @example
+ * const data = { name: 'hero', id: 123, schema: { title: 'text' } };
+ * extractFields(data, { name: true, id: true }) // => { name: 'hero', id: 123 }
+ *
+ * @example
+ * // Nested extraction
+ * extractFields(data, { schema: { title: true } }) // => { schema: { title: 'text' } }
+ */
+export declare const extractFields: (data: any, filter: any) => any;

package/dist/utils/object-utils.js

@@ -0,0 +1,71 @@
+/**
+ * General object utility functions
+ */
+/**
+ * Filter out null and undefined values from an object
+ * Keeps all properties that have defined values (including falsy values like 0, '', false)
+ *
+ * @param params - The object to filter
+ * @returns A new object with only non-nullish values
+ *
+ * @example
+ * notNullish({ a: 1, b: null, c: undefined, d: 0 }) // => { a: 1, d: 0 }
+ */
+export const notNullish = (params) => {
+    return Object.keys(params).reduce((acc, key) => {
+        if (params[key] !== null && params[key] !== undefined) {
+            acc[key] = params[key];
+        }
+        return acc;
+    }, {});
+};
+/**
+ * Check if an object is empty (has no own properties)
+ * Returns true for null, undefined, and empty objects {}
+ * Returns false for arrays (even empty ones) and objects with properties
+ *
+ * @param obj - The object to check
+ * @returns true if the object is empty, null, or undefined
+ *
+ * @example
+ * isObjectEmpty({}) // => true
+ * isObjectEmpty(null) // => true
+ * isObjectEmpty({ name: 'test' }) // => false
+ * isObjectEmpty([]) // => false (arrays are not plain objects)
+ */
+export const isObjectEmpty = (obj) => {
+    if (obj) {
+        return Object.keys(obj).length === 0 && obj.constructor === Object;
+    }
+    else {
+        return true;
+    }
+};
+/**
+ * Extract specific fields from an object based on a filter object
+ * Supports nested object extraction
+ *
+ * @param data - The source object to extract fields from
+ * @param filter - An object where true means include the field, nested objects for nested extraction
+ * @returns A new object containing only the specified fields
+ *
+ * @example
+ * const data = { name: 'hero', id: 123, schema: { title: 'text' } };
+ * extractFields(data, { name: true, id: true }) // => { name: 'hero', id: 123 }
+ *
+ * @example
+ * // Nested extraction
+ * extractFields(data, { schema: { title: true } }) // => { schema: { title: 'text' } }
+ */
+export const extractFields = (data, filter) => {
+    const result = {};
+    for (const key in filter) {
+        if (filter[key] === true) {
+            result[key] = data[key];
+        }
+        else if (typeof filter[key] === "object") {
+            result[key] = extractFields(data[key], filter[key]);
+        }
+    }
+    return result;
+};

package/dist/utils/others.d.ts

@@ -1,9 +1,6 @@
-import type { RequestBaseConfig } from "../api/utils/request.js";
-export declare const generateDatestamp: (datestamp: Date) => string;
-export declare const getFrom: (flags: any, config: RequestBaseConfig) => string;
-export declare const getTo: (flags: any, config: RequestBaseConfig) => string;
-export declare const getSourceSpace: (flags: any, config: RequestBaseConfig) => string;
-export declare const getTargetSpace: (flags: any, config: RequestBaseConfig) => string;
-export declare const getWhat: (flags: any) => string;
-export declare const getWhere: (flags: any) => string;
-export declare const getRecursive: (flags: any) => boolean;
+/**
+ * Re-exports for backwards compatibility
+ * Functions have been moved to their proper modules
+ */
+export { generateDatestamp } from "./date-utils.js";
+export { getFrom, getTo, getSourceSpace, getTargetSpace, getWhat, getWhere, getRecursive, } from "../cli/utils/cli-utils.js";

package/dist/utils/others.js

@@ -1,15 +1,8 @@
-export const generateDatestamp = (datestamp) => {
-    const year = datestamp.getFullYear();
-    const month = datestamp.getMonth() + 1;
-    const day = datestamp.getDate();
-    const hours = datestamp.getHours();
-    const minutes = datestamp.getMinutes();
-    return `${year}-${month}-${day}_${hours}-${minutes}`;
-};
-export const getFrom = (flags, config) => (flags["from"] ? flags["from"] : config.spaceId).toString();
-export const getTo = (flags, config) => (flags["to"] ? flags["to"] : config.spaceId).toString();
-export const getSourceSpace = (flags, config) => (flags["sourceSpace"] ? flags["sourceSpace"] : config.spaceId).toString();
-export const getTargetSpace = (flags, config) => (flags["targetSpace"] ? flags["targetSpace"] : config.spaceId).toString();
-export const getWhat = (flags) => (flags["what"] ? flags["what"] : "all").toString();
-export const getWhere = (flags) => (flags["where"] ? flags["where"] : "all").toString();
-export const getRecursive = (flags) => flags["recursive"] ? flags["recursive"] : false;
+/**
+ * Re-exports for backwards compatibility
+ * Functions have been moved to their proper modules
+ */
+// Date utilities - now in date-utils.ts
+export { generateDatestamp } from "./date-utils.js";
+// CLI flag extractors - now in cli/utils/cli-utils.ts
+export { getFrom, getTo, getSourceSpace, getTargetSpace, getWhat, getWhere, getRecursive, } from "../cli/utils/cli-utils.js";

package/dist/utils/path-utils.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Path and glob pattern utilities for file discovery
+ */
+/**
+ * Represents a file element with its name and path
+ */
+export interface OneFileElement {
+    name: string;
+    p: string;
+}
+/**
+ * Result of comparing local and external file arrays
+ */
+export interface CompareResult {
+    local: OneFileElement[];
+    external: OneFileElement[];
+}
+/**
+ * Request for comparing local and external file paths
+ */
+interface CompareRequest {
+    local: string[];
+    external: string[];
+}
+/**
+ * Normalizes an array of directory segments for glob pattern usage.
+ * Handles the glob.sync quirk where single segments don't need braces,
+ * but multiple segments need {segment1,segment2} format.
+ *
+ * @param segments - Array of directory path segments
+ * @returns Normalized string for glob pattern
+ *
+ * @example
+ * normalizeDiscover({ segments: [] }) // => ""
+ * normalizeDiscover({ segments: ["src"] }) // => "src"
+ * normalizeDiscover({ segments: ["src", "lib"] }) // => "{src,lib}"
+ */
+export declare const normalizeDiscover: ({ segments, }: {
+    segments: string[];
+}) => string;
+/**
+ * Builds a glob file pattern for discovering files with a specific extension.
+ * Automatically handles single vs multiple directory paths.
+ *
+ * @param mainDirectory - The root directory to search from
+ * @param componentDirectories - Array of subdirectories to search in
+ * @param ext - File extension to match (without leading dot)
+ * @returns A glob pattern string
+ *
+ * @example
+ * filesPattern({
+ *   mainDirectory: "/project",
+ *   componentDirectories: ["src"],
+ *   ext: "sb.js"
+ * })
+ * // => "/project/src/**\/[^_]*.sb.js"
+ *
+ * filesPattern({
+ *   mainDirectory: "/project",
+ *   componentDirectories: ["src", "lib"],
+ *   ext: "sb.js"
+ * })
+ * // => "/project/{src,lib}/**\/[^_]*.sb.js"
+ */
+export declare const filesPattern: ({ mainDirectory, componentDirectories, ext, }: {
+    mainDirectory: string;
+    componentDirectories: string[];
+    ext: string;
+}) => string;
+/**
+ * Compares local and external file path arrays.
+ * Splits paths to extract file names, filters out duplicates from external
+ * (preferring local files), and filters out nested node_modules.
+ *
+ * @param request - Object containing local and external path arrays
+ * @returns CompareResult with processed local and external file elements
+ *
+ * @example
+ * compare({
+ *   local: ["/project/src/hero.sb.js"],
+ *   external: ["/project/node_modules/pkg/hero.sb.js", "/project/node_modules/pkg/card.sb.js"]
+ * })
+ * // => {
+ * //   local: [{ name: "hero.sb.js", p: "/project/src/hero.sb.js" }],
+ * //   external: [{ name: "card.sb.js", p: "/project/node_modules/pkg/card.sb.js" }]
+ * // }
+ */
+export declare const compare: (request: CompareRequest) => CompareResult;
+export {};