@monosmith/plugin-sdk 0.0.0-stage → 0.2.0

package/projects/index.js

@@ -0,0 +1,6 @@
+export { auditBlocks, auditEnabled } from './audit-settings.policy.js';
+export { isManifest } from './manifest-match.algorithm.js';
+export { projectKindDirectory, resolveProjectKind } from './project-kind.policy.js';
+export { publishes } from './publishes.policy.js';
+export { setToolchain } from './set-toolchain.algorithm.js';
+export { stackPlugins } from './stack-plugins.algorithm.js';

package/projects/manifest-match.algorithm.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Whether a file's base name is one of a plugin's manifests: equal to a name,
+ * or matching a pattern (`*.csproj`). A pattern is Go's `path.Match`: `*`
+ * matches any run of characters, `?` one, `[a-z]` and `[^a-z]` a class, `\`
+ * escapes. A malformed pattern matches nothing.
+ */
+export declare function isManifest(manifests: readonly string[], base: string): boolean;

package/projects/manifest-match.algorithm.js

@@ -0,0 +1,38 @@
+/** One element of a pattern: an escaped character, a class, a wildcard, or any other character. */
+const PART = /\\(.)|\[([^\]]+)\]|([*?])|(.)/gsu;
+/**
+ * Whether a file's base name is one of a plugin's manifests: equal to a name,
+ * or matching a pattern (`*.csproj`). A pattern is Go's `path.Match`: `*`
+ * matches any run of characters, `?` one, `[a-z]` and `[^a-z]` a class, `\`
+ * escapes. A malformed pattern matches nothing.
+ */
+export function isManifest(manifests, base) {
+    return manifests.some(manifest => manifest === base || toRegExp(manifest)?.test(base) === true);
+}
+function toRegExp(pattern) {
+    let source = '^';
+    for (const [, escaped, characters, wildcard, literal] of pattern.matchAll(PART)) {
+        if (escaped !== undefined)
+            source += escape(escaped);
+        else if (characters !== undefined)
+            source += `[${characters.replaceAll('\\', String.raw `\\`)}]`;
+        else if (wildcard === '*')
+            source += '[^/]*';
+        else if (wildcard === '?')
+            source += '[^/]';
+        // A bracket or backslash that did not make an escape or a class is a malformed pattern.
+        else if (literal === '[' || literal === '\\')
+            return undefined;
+        else
+            source += escape(literal);
+    }
+    try {
+        return new RegExp(`${source}$`, 'u');
+    }
+    catch {
+        return undefined;
+    }
+}
+function escape(character) {
+    return character.replaceAll(/[.*+?^${}()|[\]\\/]/g, String.raw `\$&`);
+}

package/projects/project-kind.policy.d.ts

@@ -0,0 +1,9 @@
+import type { ProjectKind } from '../protocol/index.ts';
+/**
+ * A project's kind when its manifest may declare none: the declared kind when
+ * it is valid; otherwise the directory convention (`apps/` is an app, `libs/`
+ * a lib, `packages/` a package); and finally `fallback`.
+ */
+export declare function resolveProjectKind(declared: string | undefined, root: string, fallback: ProjectKind): ProjectKind;
+/** The conventional parent directory of a kind: `apps`, `libs` or `packages`. */
+export declare function projectKindDirectory(kind: ProjectKind): string;

package/projects/project-kind.policy.js

@@ -0,0 +1,28 @@
+const KINDS = new Set(['app', 'lib', 'package']);
+const DIRECTORY_KIND = { apps: 'app', libs: 'lib', packages: 'package' };
+/**
+ * A project's kind when its manifest may declare none: the declared kind when
+ * it is valid; otherwise the directory convention (`apps/` is an app, `libs/`
+ * a lib, `packages/` a package); and finally `fallback`.
+ */
+export function resolveProjectKind(declared, root, fallback) {
+    const kind = (declared ?? '').trim();
+    if (KINDS.has(kind))
+        return kind;
+    const top = root.split('/', 1)[0] ?? '';
+    return Object.hasOwn(DIRECTORY_KIND, top) ? DIRECTORY_KIND[top] : fallback;
+}
+/** The conventional parent directory of a kind: `apps`, `libs` or `packages`. */
+export function projectKindDirectory(kind) {
+    switch (kind) {
+        case 'app': {
+            return 'apps';
+        }
+        case 'lib': {
+            return 'libs';
+        }
+        default: {
+            return 'packages';
+        }
+    }
+}

package/projects/publishes.policy.d.ts

@@ -0,0 +1,7 @@
+import type { Project } from '../protocol/index.ts';
+/**
+ * Whether a release publishes the project to a registry: a package, unless
+ * `smith.toml` says `registry = "none"`. Plugins list the credentials a
+ * release needs only for such projects.
+ */
+export declare function publishes(project: Pick<Project, 'kind' | 'registries'>): boolean;

package/projects/publishes.policy.js

@@ -0,0 +1,8 @@
+/**
+ * Whether a release publishes the project to a registry: a package, unless
+ * `smith.toml` says `registry = "none"`. Plugins list the credentials a
+ * release needs only for such projects.
+ */
+export function publishes(project) {
+    return project.kind === 'package' && project.registries?.noPublish !== true;
+}

package/projects/set-toolchain.algorithm.d.ts

@@ -0,0 +1,7 @@
+import type { DiscoverResult } from '../protocol/index.ts';
+/**
+ * Records the toolchain on every discovered project. The probe (`node
+ * --version` and the like) runs only when there is a project, and once.
+ * Returns the result it was given.
+ */
+export declare function setToolchain(result: DiscoverResult, probe: () => string): DiscoverResult;

package/projects/set-toolchain.algorithm.js

@@ -0,0 +1,13 @@
+/**
+ * Records the toolchain on every discovered project. The probe (`node
+ * --version` and the like) runs only when there is a project, and once.
+ * Returns the result it was given.
+ */
+export function setToolchain(result, probe) {
+    if (result.projects.length === 0)
+        return result;
+    const toolchain = probe();
+    for (const project of result.projects)
+        project.toolchain = toolchain;
+    return result;
+}

package/projects/stack-plugins.algorithm.d.ts

@@ -0,0 +1,3 @@
+import type { Stack } from '../protocol/index.ts';
+/** The stack's plugins other than its language and scaffold, in the order they apply: toolchain, structure, deploy. */
+export declare function stackPlugins(stack: Pick<Stack, 'toolchain' | 'structure' | 'deploy'>): string[];

package/projects/stack-plugins.algorithm.js

@@ -0,0 +1,4 @@
+/** The stack's plugins other than its language and scaffold, in the order they apply: toolchain, structure, deploy. */
+export function stackPlugins(stack) {
+    return [...(stack.toolchain ?? []), ...(stack.structure ?? []), ...(stack.deploy ?? [])];
+}

package/protocol/index.d.ts

@@ -0,0 +1,4 @@
+export * from './protocol-types.contract.ts';
+export { protocolSchema } from './protocol-schema.contract.ts';
+export type { ErrorCodeRow, MethodRow, RoleRow, SchemaDocument, SchemaNode } from './schema-document.contract.ts';
+export { RpcError } from './rpc-error.error.ts';

package/protocol/index.js

@@ -0,0 +1,3 @@
+export * from './protocol-types.contract.js';
+export { protocolSchema } from './protocol-schema.contract.js';
+export { RpcError } from './rpc-error.error.js';

package/protocol/protocol-schema.contract.d.ts

@@ -0,0 +1,3 @@
+import type { SchemaDocument } from './schema-document.contract.ts';
+/** The JSON Schema of the plugin protocol, as committed in packages/plugin-sdk/schema. */
+export declare const protocolSchema: SchemaDocument;