@_linked/cli 1.4.1 → 1.4.3

package/lib/cjs/commands/build-package.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Given any file or directory path, walk up to find the nearest package.json
+ * and run `linked build` in that package's directory. This is the editor-hook
+ * variant of build: the caller knows a file path, we figure out the package.
+ *
+ * Only rebuilds packages flagged `linkedPackage: true` (or legacy `lincd: true`).
+ */
+export declare function buildPackageByPath(filePath: string): Promise<void>;
+//# sourceMappingURL=build-package.d.ts.map

package/lib/cjs/commands/safe-yarn.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Run a yarn command at the workspace root while preserving nested repositories'
+ * yarn.lock files. Used when the workspace contains sibling repos (via mrgit)
+ * whose own lockfiles should not be clobbered by a root-level `yarn install`.
+ *
+ * Reads mrgit.json to determine which nested repos exist. If mrgit.json is
+ * missing, falls back to plain yarn behavior.
+ */
+export declare function safeYarn(args: string[]): Promise<void>;
+//# sourceMappingURL=safe-yarn.d.ts.map

package/lib/cjs/commands/setup-publish.d.ts

@@ -0,0 +1,23 @@
+export type SetupPublishOptions = {
+    configureGithub?: boolean;
+    scope?: 'core' | 'community';
+    dualBranch?: boolean;
+    grantTeam?: string;
+};
+/**
+ * Set up a single-branch changesets publish workflow in the current package repo.
+ *
+ * Installs:
+ * - .github/workflows/{ci,publish,changeset-check}.yml
+ * - .changeset/config.json + README.md
+ * - .changeset/initial-release.md
+ * - .gitignore entries for node_modules, lib, yarn.lock, src-compiled-artifacts
+ * - package.json: @changesets/cli + @changesets/changelog-github devDeps,
+ *   publishConfig: {access: public}
+ * - package-lock.json generated via npm install --package-lock-only
+ *
+ * With --configure-github: if `gh` CLI is available and authenticated, also sets
+ * branch protection on main (strict + required "Build & Test" check).
+ */
+export declare function setupPublish(opts?: SetupPublishOptions): Promise<void>;
+//# sourceMappingURL=setup-publish.d.ts.map

package/lib/cjs/config-webpack-app.d.ts

@@ -0,0 +1,112 @@
+import TerserPlugin from 'terser-webpack-plugin';
+import { LinkedConfig } from './interfaces.js';
+/**
+ * Converts a css class name to a unique scoped name (for CSS Modules)
+ * @param context
+ * @param currentFormat
+ * @param name
+ */
+declare function getLocalIdent(context: any, currentFormat: any, name: any): string;
+export declare const getLinkedConfig: () => Promise<LinkedConfig>;
+export declare const getWebpackAppConfig: () => Promise<{
+    mode: string;
+    devtool: string;
+    entry: string[];
+    watch: boolean;
+    output: {
+        path: string;
+        filename: string;
+        publicPath: string;
+        clean: boolean;
+    };
+    watchOptions: {
+        ignored: RegExp;
+        aggregateTimeout: number;
+    };
+    devServer: {
+        client: {
+            progress: boolean;
+        };
+    };
+    plugins: any[];
+    externals: {
+        [npmModule: string]: string;
+    };
+    module: {
+        rules: ({
+            test: RegExp;
+            use: (string | {
+                loader: string;
+                options: {
+                    url: boolean;
+                    importLoaders: number;
+                    modules: {
+                        mode: string;
+                        getLocalIdent: typeof getLocalIdent;
+                        auto: (resourcePath: string) => boolean;
+                    };
+                    postcssOptions?: undefined;
+                };
+            } | {
+                loader: string;
+                options: {
+                    postcssOptions: {
+                        plugins: any[];
+                    };
+                    url?: undefined;
+                    importLoaders?: undefined;
+                    modules?: undefined;
+                };
+            })[];
+            exclude?: undefined;
+        } | {
+            test: RegExp;
+            use: {
+                loader: string;
+                options: {
+                    transpileOnly: boolean;
+                    getCustomTransformers?: () => {
+                        before: import("typescript").TransformerFactory<import("typescript").SourceFile>[];
+                    };
+                };
+            }[];
+            exclude: RegExp;
+        })[];
+    };
+    optimization: {
+        minimize: boolean;
+        minimizer: TerserPlugin<{
+            keep_classnames: boolean;
+        }>[];
+        splitChunks: {
+            cacheGroups: {
+                defaultVendors: boolean;
+                default: boolean;
+            };
+        };
+    };
+    stats: {
+        chunks: boolean;
+        assets: boolean;
+        entrypoints: boolean;
+        children: boolean;
+        modules: boolean;
+    };
+    resolve: {
+        extensions: string[];
+        alias: {
+            [oldNpmPath: string]: string;
+        };
+        extensionAlias: {
+            '.js': string[];
+            '.jsx': string[];
+        };
+    };
+    cache: {
+        type: "filesystem";
+    } | {
+        type: "memory";
+    };
+}>;
+export {};
+//# sourceMappingURL=config-webpack-app.d.ts.map

package/lib/cjs/config-webpack.d.ts

@@ -0,0 +1,55 @@
+import { AdjustedModuleConfig } from './interfaces';
+import TerserPlugin from 'terser-webpack-plugin';
+export declare function generateWebpackConfig(buildName: any, moduleName: any, config?: AdjustedModuleConfig): {
+    entry: any;
+    output: {
+        filename: string;
+        path: string;
+        devtoolModuleFilenameTemplate: string;
+    };
+    devtool: string;
+    mode: string;
+    resolve: {
+        extensions: string[];
+        alias: {
+            [oldNpmPath: string]: string;
+        };
+        fallback: {
+            crypto: boolean;
+        };
+    };
+    resolveLoader: {
+        modules: string[];
+    };
+    optimization: {
+        minimize: boolean;
+        minimizer: TerserPlugin<import("terser").MinifyOptions>[];
+    };
+    watch: boolean;
+    watchOptions: {
+        ignored: string[];
+        aggregateTimeout: number;
+    };
+    module: {
+        rules: any[];
+    };
+    externals: ({ context, request, contextInfo }: {
+        context: any;
+        request: any;
+        contextInfo: any;
+    }, callback: any) => any;
+    plugins: any[];
+    stats: {
+        errorDetails: boolean;
+        chunks: boolean;
+        children: boolean;
+        version: boolean;
+        hash: boolean;
+        entrypoints: boolean;
+        modules: boolean;
+    };
+    cache: {
+        type: string;
+    };
+};
+//# sourceMappingURL=config-webpack.d.ts.map

package/lib/cjs/defineConfig.d.ts

@@ -0,0 +1,8 @@
+import { LinkedConfig } from './interfaces';
+/**
+ * Define a Linked configuration with type checking and autocomplete
+ * @param config The configuration object
+ * @returns The same configuration object (identity function for type inference)
+ */
+export declare function defineConfig(config: LinkedConfig): LinkedConfig;
+//# sourceMappingURL=defineConfig.d.ts.map

package/lib/cjs/index.d.ts

@@ -0,0 +1,12 @@
+export { default as DeclarationPlugin } from './plugins/declaration-plugin';
+export { default as externaliseModules } from './plugins/externalise-modules';
+export { default as tailwindConfig } from './tailwind.config';
+import { generateWebpackConfig } from './config-webpack';
+export { generateWebpackConfig };
+export * from './utils';
+export { defineConfig } from './defineConfig';
+export type { LinkedConfig, LinkedWebpackConfig, LinkedServerConfig, } from './interfaces';
+export { buildPackageByPath } from './commands/build-package';
+export { safeYarn } from './commands/safe-yarn';
+export { setupPublish } from './commands/setup-publish';
+//# sourceMappingURL=index.d.ts.map

package/lib/cjs/interfaces.d.ts

@@ -0,0 +1,131 @@
+export interface ModuleConfig {
+    internals?: string[] | '*';
+    entry?: string;
+    filename?: string;
+    declarations?: boolean;
+    internalsources?: string[];
+    externals?: {
+        [npmModule: string]: string;
+    };
+    target?: 'es5' | 'es6';
+    es5?: ModuleConfig;
+    es6?: ModuleConfig;
+    dev?: ModuleConfig;
+    prod?: ModuleConfig;
+    debug?: boolean;
+    alias?: {
+        [oldNpmPath: string]: string;
+    };
+    provide?: {};
+    environment?: 'nodejs' | 'browser' | 'polymorphic';
+    outputPath?: string;
+    bundlePath?: string;
+    es5Server?: boolean;
+    analyse?: boolean;
+    cssIdentName?: string;
+    beforeBuildCommand?: string;
+    afterBuildCommand?: string;
+    afterBuildCommandProduction?: string;
+    afterFirstBuildCommand?: string;
+    cssGlobalModulePaths?: string;
+    cssMode?: 'tailwind' | 'postcss';
+    cssFileName?: string;
+    tsConfigOverwrites?: Object;
+}
+export interface AdjustedModuleConfig extends ModuleConfig {
+    watch?: boolean;
+    productionMode?: boolean;
+}
+export interface PackageDetails {
+    path: string;
+    packageName: string;
+}
+/**
+ * Webpack build configuration
+ */
+export interface LinkedWebpackConfig {
+    /**
+     * Enable webpack filesystem caching for faster rebuilds
+     * @default true
+     */
+    cache?: boolean;
+    /**
+     * Enable webpack bundle analyzer to visualize bundle size
+     * @default false
+     */
+    analyse?: boolean;
+    /**
+     * Additional webpack plugins
+     */
+    plugins?: any[];
+    /**
+     * Webpack externals configuration - modules to exclude from bundle
+     */
+    externals?: {
+        [npmModule: string]: string;
+    };
+    /**
+     * Webpack alias configuration for import path shortcuts
+     */
+    alias?: {
+        [oldNpmPath: string]: string;
+    };
+    /**
+     * Patterns for CSS files that should not use CSS Modules
+     */
+    cssGlobalModulePaths?: (RegExp | string)[];
+}
+/**
+ * Server-specific configuration
+ */
+export interface LinkedServerConfig {
+    /**
+     * Paths to cache for server-side rendering (SSR)
+     * Cached pages will be served from memory for faster response times
+     */
+    cachePaths?: string[];
+    /**
+     * Cache timeout in milliseconds for SSR rendered pages
+     * After this time, cached pages will be re-rendered
+     * @default 300000 (5 minutes)
+     */
+    cacheTimeout?: number;
+    /**
+     * Enable multi-core server processing (requires @semantu/multicore)
+     * Spawns worker processes to handle requests across multiple CPU cores
+     * @default false
+     */
+    multiCore?: boolean;
+    /**
+     * Function that loads the app component (for SSR and hot reloading)
+     * Must be a function to support hot module reloading
+     */
+    loadAppComponent?: () => any;
+    /**
+     * Function that loads the app routes configuration (for SSR preloading)
+     * Must be a function to support hot module reloading
+     * Should return a RoutesModule from 'lincd-server'
+     */
+    loadRoutes?: () => Promise<any>;
+}
+/**
+ * Complete Linked configuration
+ */
+export interface LinkedConfig {
+    /**
+     * CSS processing mode (shared by webpack and server for SSR)
+     * - 'tailwind': Use Tailwind CSS v4 with @tailwindcss/postcss. Still supports CSS Modules for .module.css files
+     * - 'postcss': Use PostCSS with nesting support and CSS Modules for .module.css files
+     * @default 'postcss'
+     */
+    cssMode?: 'tailwind' | 'postcss';
+    /**
+     * Webpack build configuration
+     */
+    webpack?: LinkedWebpackConfig;
+    /**
+     * Server configuration
+     */
+    server?: LinkedServerConfig;
+}
+//# sourceMappingURL=interfaces.d.ts.map

package/lib/cjs/loaders/register-css-only.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=register-css-only.d.ts.map

package/lib/cjs/loaders/register.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=register.d.ts.map

package/lib/cjs/metadata.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=metadata.d.ts.map

package/lib/cjs/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@_linked/cli",
-  "version": "1.4.1",
+  "version": "1.4.3",
   "description": "Command line tools for the @_linked/* packages and apps",
   "typesVersions": {
     "*": {

package/lib/cjs/plugins/check-imports.d.ts

@@ -0,0 +1,2 @@
+export default function handler(source: any): any;
+//# sourceMappingURL=check-imports.d.ts.map

package/lib/cjs/plugins/declaration-plugin.d.ts

@@ -0,0 +1,15 @@
+export default class DeclarationPlugin {
+    options: any;
+    moduleName: string;
+    excludedReferences: string[];
+    logMessages: boolean;
+    modulePackageInfo: any;
+    declarationFiles: any;
+    private exportRoot;
+    constructor(options?: any);
+    apply(compiler: any): void;
+    private debug;
+    private log;
+    private generateCombinedDeclaration;
+}
+//# sourceMappingURL=declaration-plugin.d.ts.map

package/lib/cjs/plugins/externalise-modules.d.ts

@@ -0,0 +1,7 @@
+declare var externaliseModules: (config: any, es5: any) => ({ context, request, contextInfo }: {
+    context: any;
+    request: any;
+    contextInfo: any;
+}, callback: any) => any;
+export default externaliseModules;
+//# sourceMappingURL=externalise-modules.d.ts.map

package/lib/cjs/plugins/lincd-tailwind-sources.d.ts

@@ -0,0 +1,3 @@
+declare const getLincdSources: () => string[];
+export default getLincdSources;
+//# sourceMappingURL=lincd-tailwind-sources.d.ts.map

package/lib/cjs/plugins/watch-run.d.ts

@@ -0,0 +1,5 @@
+declare class WatchRunPlugin {
+    apply(compiler: any): void;
+}
+export default WatchRunPlugin;
+//# sourceMappingURL=watch-run.d.ts.map

package/lib/cjs/tailwind.config.d.ts

@@ -0,0 +1,8 @@
+declare const config: {
+    content: string[];
+    theme: {
+        extend: {};
+    };
+};
+export default config;
+//# sourceMappingURL=tailwind.config.d.ts.map

package/lib/cjs/utils.d.ts

@@ -0,0 +1,77 @@
+import { ExecOptions } from 'child_process';
+import { PackageDetails } from './interfaces.js';
+export declare var getFileImports: (filePath: any) => Promise<string[]>;
+/**
+ *
+ * @param importPath The import path to check
+ * @param curFileDepth How many folders deep the current file is (0 = src, 1 = src/foo, etc.)
+ * @returns
+ */
+export declare var isInvalidLINCDImport: (importPath: string, curFileDepth: number) => boolean;
+export declare var isImportOutsideOfPackage: (importPath: string, curFileDepth: number) => boolean;
+/**
+ *
+ * @param importPath The import path to check
+ * @param curFileDepth How many folders deep the current file is (0 = src, 1 = src/foo, etc.)
+ * @returns
+ */
+export declare var isValidLINCDImport: (importPath: string, curFileDepth: number) => boolean;
+export declare var isImportWithMissingExtension: (importPath: string) => boolean;
+export declare var getPackageJSON: (root?: string, error?: boolean) => any;
+/**
+ * Scans package.json for dependencies that are LINCD packages
+ * Also looks into dependencies of dependencies
+ * If no packageJson is given, it will attempt to obtain it from the current working directory
+ * Returns an array of lincd packages, with each entry containing an array with the package name and the local path to the package
+ * @param packageJson
+ */
+export declare var getLINCDDependencies: (packageJson?: any, checkedPackages?: Set<string>) => [string, string, string[]][];
+export declare const getLastBuildTime: (packagePath: any) => {
+    lastModified: Date;
+    lastModifiedName: any;
+    lastModifiedTime: number;
+};
+export declare const getLastModifiedSourceTime: (packagePath: any) => {
+    lastModified: Date;
+    lastModifiedName: any;
+    lastModifiedTime: number;
+};
+export declare const getLastCommitTime: (packagePath: any) => Promise<{
+    date: Date;
+    changes: string;
+    commitId: string;
+}>;
+export declare const getLastModifiedFile: (filePath: any, config?: {}) => {
+    lastModified: Date;
+    lastModifiedName: any;
+    lastModifiedTime: number;
+};
+export declare var getModulePackageJSON: (module_name: any, work_dir?: any) => any;
+export declare function execp(cmd: any, log?: boolean, allowError?: boolean, options?: any): Promise<null>;
+export declare function execPromise(command: any, log?: boolean, allowError?: boolean, options?: ExecOptions, pipeOutput?: boolean): Promise<string>;
+export declare function generateScopedNameProduction(cssClassName: any, filepath: any, css?: any): string;
+export declare function generateScopedName(cssClassName: any, filepath: any, css?: any): string;
+export declare const needsRebuilding: (pkg: PackageDetails, useGitForLastModified: boolean, log?: boolean) => Promise<boolean>;
+export declare function log(...messages: any[]): void;
+export declare function debug(config: any, ...messages: any[]): void;
+export declare function debugInfo(...messages: any[]): void;
+export declare function warn(...messages: any[]): void;
+export declare function flatten(arr: any): any;
+export declare function getLinkedTailwindColors(): {
+    'primary-color': string;
+    'font-color': string;
+};
+/**
+ * Recursively get all files in a directory
+ * https://stackoverflow.com/a/45130990/831465
+ * @param dir The directory to get files from
+ * @returns A promise that resolves to an array of file paths
+ */
+export declare function getFiles(dir: string, filenameFilter?: string): Promise<string[]>;
+/**
+ * Strip ANSI escape codes from a string
+ * @param str The string to strip ANSI codes from
+ * @returns The string with ANSI codes removed
+ */
+export declare function stripAnsi(str: string): string;
+//# sourceMappingURL=utils.d.ts.map

package/lib/esm/cli-deprecated.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env tsx
+//# sourceMappingURL=cli-deprecated.d.ts.map

package/lib/esm/cli-methods.d.ts

@@ -0,0 +1,67 @@
+import { PackageDetails } from './interfaces';
+export declare const createApp: (name: any, basePath?: string, options?: {
+    appName?: string;
+    appPrefix?: string;
+    appDomain?: string;
+    skipInstall?: boolean;
+}) => Promise<void>;
+export declare function warn(...messages: any[]): void;
+export declare function logError(...errors: any[]): void;
+export declare function developPackage(target: any, mode: any): void;
+export declare function runOnPackagesGroupedByDependencies(lincdPackages: any, onBuildStack: (packageGroup: any, dependencies: any) => (pkg: PackageDetails) => Promise<any>, onStackEnd: any, sync?: boolean): Promise<void>;
+export declare function buildAll(options: any): void;
+export declare function getLincdPackages(rootPath?: string): PackageDetails[];
+export declare const createOntology: (prefix: any, uriBase?: any, basePath?: string) => Promise<void>;
+export declare const setNameVariables: (name: any) => {
+    hyphenName: any;
+    camelCaseName: any;
+    underscoreName: any;
+    plainName: any;
+};
+/**
+ * get __dirname for either ESM/CJS
+ */
+export declare const getScriptDir: () => string;
+export declare const createShape: (name: any, basePath?: string) => Promise<void>;
+export declare const createSetComponent: (name: any, basePath?: string) => Promise<void>;
+export declare const createComponent: (name: any, basePath?: string) => Promise<void>;
+export declare const checkImports: (sourceFolder?: string, depth?: number, // Used to check if the import is outside the src folder
+invalidImports?: Map<string, {
+    type: string;
+    importPath: string;
+}[]>) => Promise<boolean>;
+export declare const depCheckStaged: () => Promise<void>;
+export declare const depCheck: (packagePath?: string) => Promise<unknown>;
+export declare const ensureEnvironmentLoaded: () => Promise<void>;
+export declare const runScript: (scriptName: string, options: {
+    spawn: boolean;
+}) => Promise<never>;
+export declare const runMethod: (packageName: string, method: string, options: {
+    spawn: boolean;
+}) => Promise<void>;
+export declare const startServer: (initOnly?: boolean, ServerClass?: any) => Promise<any>;
+export declare const buildApp: () => Promise<never>;
+export declare const buildFrontend: () => Promise<void>;
+export declare const buildBackend: () => Promise<boolean>;
+export declare const upgradePackages: () => Promise<void>;
+export declare const createPackage: (name: any, uriBase?: any, basePath?: string) => Promise<void>;
+export declare const register: (registryURL: any) => Promise<void>;
+export declare const buildPackage: (target: any, target2: any, packagePath?: string, logResults?: boolean) => Promise<any>;
+export declare const compilePackage: (packagePath?: string) => Promise<void>;
+export declare const compilePackageESM: (packagePath?: string) => Promise<boolean>;
+export declare const compilePackageCJS: (packagePath?: string) => Promise<boolean | {
+    error: any;
+}>;
+export declare var publishUpdated: (test?: boolean) => Promise<void>;
+export declare var publishPackage: (pkg?: any, test?: any, info?: any, publishVersion?: any) => Promise<string>;
+export declare var buildUpdated: (back: any, target: any, target2: any, useGitForLastModified?: boolean, test?: boolean) => Promise<void>;
+export declare var executeCommandForEachPackage: (packages: any, command: any, filterMethod: any, filterValue: any) => Promise<boolean>;
+export declare var addLinesToFile: (filePath: any, entries: any) => void;
+export declare var addCapacitor: (basePath?: string) => Promise<void>;
+export declare var executeCommandForPackage: (packageName: any, command: any) => void;
+/**
+ * Function to remove files older than 10 seconds from the 'lib' folder.
+ * @param {string} packagePath - The path to the package directory.
+ */
+export declare const removeOldFiles: (packagePath: any) => Promise<boolean>;
+//# sourceMappingURL=cli-methods.d.ts.map

package/lib/esm/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env tsx
+import 'require-extensions';
+//# sourceMappingURL=cli.d.ts.map

package/lib/esm/commands/build-package.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Given any file or directory path, walk up to find the nearest package.json
+ * and run `linked build` in that package's directory. This is the editor-hook
+ * variant of build: the caller knows a file path, we figure out the package.
+ *
+ * Only rebuilds packages flagged `linkedPackage: true` (or legacy `lincd: true`).
+ */
+export declare function buildPackageByPath(filePath: string): Promise<void>;
+//# sourceMappingURL=build-package.d.ts.map

package/lib/esm/commands/safe-yarn.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Run a yarn command at the workspace root while preserving nested repositories'
+ * yarn.lock files. Used when the workspace contains sibling repos (via mrgit)
+ * whose own lockfiles should not be clobbered by a root-level `yarn install`.
+ *
+ * Reads mrgit.json to determine which nested repos exist. If mrgit.json is
+ * missing, falls back to plain yarn behavior.
+ */
+export declare function safeYarn(args: string[]): Promise<void>;
+//# sourceMappingURL=safe-yarn.d.ts.map

package/lib/esm/commands/setup-publish.d.ts

@@ -0,0 +1,23 @@
+export type SetupPublishOptions = {
+    configureGithub?: boolean;
+    scope?: 'core' | 'community';
+    dualBranch?: boolean;
+    grantTeam?: string;
+};
+/**
+ * Set up a single-branch changesets publish workflow in the current package repo.
+ *
+ * Installs:
+ * - .github/workflows/{ci,publish,changeset-check}.yml
+ * - .changeset/config.json + README.md
+ * - .changeset/initial-release.md
+ * - .gitignore entries for node_modules, lib, yarn.lock, src-compiled-artifacts
+ * - package.json: @changesets/cli + @changesets/changelog-github devDeps,
+ *   publishConfig: {access: public}
+ * - package-lock.json generated via npm install --package-lock-only
+ *
+ * With --configure-github: if `gh` CLI is available and authenticated, also sets
+ * branch protection on main (strict + required "Build & Test" check).
+ */
+export declare function setupPublish(opts?: SetupPublishOptions): Promise<void>;
+//# sourceMappingURL=setup-publish.d.ts.map