@_linked/cli 1.4.2 → 1.4.3

package/lib/esm/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/esm/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/esm/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/esm/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/esm/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/esm/launch.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=launch.d.ts.map

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

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

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

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

package/lib/esm/metadata.d.ts

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

package/lib/esm/package.json

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

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

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

package/lib/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@_linked/cli",
-  "version": "1.4.2",
+  "version": "1.4.3",
   "description": "Command line tools for the @_linked/* packages and apps",
   "main": "lib/cjs/index.js",
   "module": "lib/esm/index.js",

package/tests/e2e/create-app.spec.ts

@@ -0,0 +1,157 @@
+// End-to-end: scaffold a Linked app via `linked create-app`, install, start it
+// against a fresh Fuseki container, then drive the Person CRUD flow.
+//
+// Self-contained: scaffolds into an OS tmpdir, installs deps from npm,
+// starts a Fuseki testcontainer, exercises the Person fixture. No
+// dependency on any parent monorepo. Companion `@_linked/*` packages
+// must be published to npm at compatible versions; if they aren't yet,
+// set SKIP_E2E=1 to skip this test.
+import {test, expect} from '@playwright/test';
+import {GenericContainer, Wait, StartedTestContainer} from 'testcontainers';
+import {spawn, ChildProcess, execSync} from 'node:child_process';
+import {rmSync, existsSync, mkdtempSync} from 'node:fs';
+import {tmpdir} from 'node:os';
+import {dirname, join, resolve} from 'node:path';
+import {fileURLToPath} from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const CLI_LAUNCH = resolve(__dirname, '../../lib/esm/launch.js');
+
+// Deterministic-enough app name; salted so concurrent runs don't collide.
+const APP_NAME = `e2e-test-app-${process.pid}`;
+const SCAFFOLD_ROOT = mkdtempSync(join(tmpdir(), 'linked-cli-e2e-'));
+const APP_DIR = join(SCAFFOLD_ROOT, APP_NAME);
+const DATASET = `${APP_NAME}-main`;
+const APP_PORT = 4400 + (process.pid % 100); // avoid collision with a CN backend on 4040
+
+let fuseki: StartedTestContainer;
+let appProc: ChildProcess | null = null;
+let fusekiUrl: string;
+
+test.beforeAll(async () => {
+  if (process.env.SKIP_E2E === '1') test.skip();
+
+  // 1. Start a fresh Fuseki container with a random host port.
+  fuseki = await new GenericContainer('stain/jena-fuseki')
+    .withExposedPorts(3030)
+    .withEnvironment({ADMIN_PASSWORD: 'admin'})
+    .withWaitStrategy(Wait.forLogMessage(/Started.*Server/))
+    .start();
+  fusekiUrl = `http://${fuseki.getHost()}:${fuseki.getMappedPort(3030)}`;
+
+  // 2. Scaffold the app via the local CLI build.
+  if (existsSync(APP_DIR)) rmSync(APP_DIR, {recursive: true, force: true});
+  execSync(
+    `node ${CLI_LAUNCH} create-app ${APP_NAME} --app-name "E2E" --app-prefix e2e --app-domain e2e.local --skip-install`,
+    {cwd: SCAFFOLD_ROOT, stdio: 'inherit'},
+  );
+
+  // 3. Create the matching dataset in Fuseki. Template default is
+  // `${hyphen_name}-main` → matches DATASET above.
+  const adminAuth = Buffer.from('admin:admin').toString('base64');
+  const resp = await fetch(`${fusekiUrl}/$/datasets`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/x-www-form-urlencoded',
+      Authorization: `Basic ${adminAuth}`,
+    },
+    body: `dbName=${DATASET}&dbType=mem`,
+  });
+  if (!resp.ok && resp.status !== 409) {
+    throw new Error(`Failed to create dataset: ${resp.status} ${await resp.text()}`);
+  }
+
+  // 4. Install scaffolded app deps from npm. The scaffolded package.json
+  // pins @_linked/* versions; install resolves them straight from the
+  // registry (no workspace symlinks involved).
+  execSync('yarn install', {cwd: APP_DIR, stdio: 'inherit'});
+
+  // 5. Boot the app with env overrides pointing at the testcontainer Fuseki.
+  appProc = spawn('yarn', ['start'], {
+    cwd: APP_DIR,
+    env: {
+      ...process.env,
+      FUSEKI_BASE_URL: fusekiUrl,
+      FUSEKI_DATASET: DATASET,
+      PORT: String(APP_PORT),
+    },
+    stdio: 'inherit',
+  });
+
+  // 6. Wait for HTTP 200 on /.
+  await waitForServer(`http://localhost:${APP_PORT}/`, 90_000);
+}, /* timeout */ 4 * 60 * 1000);
+
+test.afterAll(async () => {
+  // Kill the app server.
+  if (appProc) {
+    appProc.kill('SIGTERM');
+    await new Promise((r) => setTimeout(r, 1000));
+    if (!appProc.killed) appProc.kill('SIGKILL');
+  }
+
+  // Drop the Fuseki dataset (idempotent).
+  try {
+    const adminAuth = Buffer.from('admin:admin').toString('base64');
+    await fetch(`${fusekiUrl}/$/datasets/${DATASET}`, {
+      method: 'DELETE',
+      headers: {Authorization: `Basic ${adminAuth}`},
+    });
+  } catch {
+    // Container may be gone already; ignore.
+  }
+
+  // Stop testcontainer.
+  await fuseki?.stop().catch(() => {});
+
+  // Remove scaffolded app folder + its parent tmpdir.
+  if (existsSync(SCAFFOLD_ROOT)) {
+    rmSync(SCAFFOLD_ROOT, {recursive: true, force: true});
+  }
+}, /* timeout */ 2 * 60 * 1000);
+
+test('Person fixture: add → edit → delete round-trip', async ({page}) => {
+  await page.goto(`http://localhost:${APP_PORT}/`);
+  await expect(page.getByTestId('person-overview')).toBeVisible();
+
+  // Add Alice
+  await page.getByPlaceholder('First name').fill('Alice');
+  await page.getByPlaceholder('Last name').fill('Anderson');
+  await page.getByRole('button', {name: 'Add'}).click();
+  await expect(page.getByTestId('person-name').filter({hasText: 'Alice Anderson'})).toBeVisible();
+
+  // Edit to Alicia
+  await page.getByRole('button', {name: 'Edit'}).first().click();
+  const editRow = page.getByTestId('person-edit').first();
+  await editRow.getByLabel('First name').fill('Alicia');
+  await editRow.getByRole('button', {name: 'Save'}).click();
+  await expect(
+    page.getByTestId('person-name').filter({hasText: 'Alicia Anderson'}),
+  ).toBeVisible();
+
+  // Reload — change must persist
+  await page.reload();
+  await expect(
+    page.getByTestId('person-name').filter({hasText: 'Alicia Anderson'}),
+  ).toBeVisible();
+
+  // Delete — row disappears
+  await page.getByRole('button', {name: 'Delete'}).first().click();
+  await expect(
+    page.getByTestId('person-name').filter({hasText: 'Alicia Anderson'}),
+  ).toBeHidden();
+});
+
+async function waitForServer(url: string, timeoutMs: number): Promise<void> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      const r = await fetch(url, {method: 'GET'});
+      if (r.ok) return;
+    } catch {
+      /* not ready yet */
+    }
+    await new Promise((res) => setTimeout(res, 1000));
+  }
+  throw new Error(`Server at ${url} did not respond within ${timeoutMs}ms`);
+}