@adecore/editor-react 0.39.0 → 0.40.1

package/src/snippet-transform-queue.ts

@@ -9,10 +9,12 @@ interface RequestOptions {
     readonly kind?: 'accept' | 'exit';
     readonly current?: () => boolean;
 }
+
 export interface SnippetTransformLease {
     request(jobs: readonly SnippetTransformJob[], options?: RequestOptions): Promise<readonly string[]>;
     dispose(): void;
 }
+
 interface Job {
     readonly owner: symbol;
     readonly kind: 'accept' | 'exit';
@@ -21,6 +23,7 @@ interface Job {
     readonly resolve: (values: readonly string[]) => void;
     readonly reject: (error: unknown) => void;
 }
+
 export class SnippetTransformQueueError extends Error {}
 
 const IDLE_RELEASE_MS = 1000;
@@ -34,91 +37,121 @@ export class SnippetTransforms {
     private active: Job | null = null;
     private idle: unknown;
     private disposed = false;
+
     constructor(factory: () => WorkerRequestPort, timers: Timers = realTimers) {
         this.timers = timers;
+
         this.client = createSnippetTransformClient({
             workerFactory: factory,
             schedule: (callback, delay) => {
                 const timer = timers.set(callback, delay);
+
                 return () => timers.clear(timer);
             }
         });
     }
+
     acquire(): SnippetTransformLease {
         const owner = Symbol('snippet');
         this.owners.add(owner);
+
         return {
             request: (jobs, options = {}) => this.request(owner, jobs, options),
             dispose: () => this.releaseOwner(owner)
         };
     }
+
     private request(owner: symbol, jobs: readonly SnippetTransformJob[], options: RequestOptions): Promise<readonly string[]> {
         if (this.disposed || !this.owners.has(owner)) {
             return Promise.reject(new SnippetTransformError('disposed', 'The snippet owner was disposed.'));
         }
+
         let copied: SnippetTransformJob[];
+
         try {
             validateSnippetTransformJobs(jobs);
+
             if (jobs.reduce((sum, job) => sum + job.value.length, 0) > MAX_TRANSFORM_WORK) {
                 throw new RangeError('The snippet transform inputs exceed the work budget.');
             }
+
             copied = jobs.map((job) => ({ ...job, format: job.format.map((node) => ({ ...node })) }));
         } catch (error) {
             return Promise.reject(
                 new SnippetTransformError(error instanceof RangeError ? 'range' : 'syntax', error instanceof Error ? error.message : String(error))
             );
         }
+
         if (copied.length === 0) {
             return Promise.resolve([]);
         }
+
         this.pending = this.pending.filter((job) => {
             if (job.current()) {
                 return true;
             }
+
             job.reject(new SnippetTransformError('superseded', 'The queued snippet changed.'));
+
             return false;
         });
+
         const kind = options.kind ?? 'accept';
+
         if (kind === 'accept') {
             this.pending = this.pending.filter((job) => {
                 if (job.owner !== owner || job.kind !== 'accept') {
                     return true;
                 }
+
                 job.reject(new SnippetTransformError('superseded', 'A newer snippet accept replaced the queued one.'));
+
                 return false;
             });
         }
+
         if (this.pending.length >= MAX_PENDING) {
             return Promise.reject(new SnippetTransformQueueError('Too many queued snippet transforms.'));
         }
+
         this.timers.clear(this.idle);
+
         return new Promise((resolve, reject) => {
             this.pending.push({ owner, kind, jobs: copied, current: () => this.owners.has(owner) && (options.current?.() ?? true), resolve, reject });
             queueMicrotask(() => this.pump());
         });
     }
+
     private pump(): void {
         if (this.disposed || this.active !== null) {
             return;
         }
+
         const job = this.pending.shift();
+
         if (job === undefined) {
             this.timers.clear(this.idle);
             this.idle = this.timers.set(() => this.client.release(), IDLE_RELEASE_MS);
+
             return;
         }
+
         if (!job.current()) {
             job.reject(new SnippetTransformError('superseded', 'The queued snippet changed.'));
             this.pump();
+
             return;
         }
+
         this.active = job;
+
         void this.client
             .transform(job.jobs)
             .then((values) => {
                 if (!job.current()) {
                     throw new SnippetTransformError('superseded', 'The snippet changed while transforming.');
                 }
+
                 job.resolve(values);
             })
             .catch((error) => job.reject(error))
@@ -127,29 +160,37 @@ export class SnippetTransforms {
                 this.pump();
             });
     }
+
     private releaseOwner(owner: symbol): void {
         if (!this.owners.delete(owner)) {
             return;
         }
+
         this.pending = this.pending.filter((job) => {
             if (job.owner !== owner) {
                 return true;
             }
+
             job.reject(new SnippetTransformError('disposed', 'The snippet owner was disposed.'));
+
             return false;
         });
+
         if (this.active?.owner === owner) {
             this.active.reject(new SnippetTransformError('disposed', 'The snippet owner was disposed.'));
             this.client.cancel();
         }
+
         if (this.owners.size === 0) {
             this.dispose();
         }
     }
+
     dispose(): void {
         if (this.disposed) {
             return;
         }
+
         this.disposed = true;
         this.timers.clear(this.idle);
         this.owners.clear();
@@ -160,39 +201,51 @@ export class SnippetTransforms {
         this.client.dispose();
     }
 }
+
 interface Entry {
     readonly queue: SnippetTransforms;
     references: number;
 }
+
 const projects = new WeakMap<ProjectLanguage, Entry>();
+
 export function acquireSnippetTransforms(project: ProjectLanguage, timers: Timers): SnippetTransformLease | null {
     const factory = project.host.snippetTransformWorker;
+
     if (factory === undefined) {
         return null;
     }
+
     let entry = projects.get(project);
+
     if (entry === undefined) {
         entry = { queue: new SnippetTransforms(factory, timers), references: 0 };
         projects.set(project, entry);
     }
+
     const held = entry,
         lease = held.queue.acquire();
+
     held.references++;
     let disposed = false;
+
     return {
         request: (jobs, options) => lease.request(jobs, options),
         dispose: () => {
             if (disposed) {
                 return;
             }
+
             disposed = true;
             lease.dispose();
+
             if (--held.references === 0 && projects.get(project) === held) {
                 projects.delete(project);
             }
         }
     };
 }
+
 export function disposeSnippetTransforms(project: ProjectLanguage): void {
     projects.get(project)?.queue.dispose();
     projects.delete(project);

package/src/snippet-transform-worker.ts

@@ -1,5 +1,6 @@
 import { applySnippetTransform, createSnippetTransformBudget, validateSnippetTransformJobs } from './snippet-transform-format.ts';
 import { MAX_TRANSFORM_CHARACTERS, type SnippetTransformInput, type SnippetTransformOutput } from './snippet-transform-protocol.ts';
+
 export {
     createSnippetTransformClient,
     SnippetTransformError,
@@ -7,7 +8,9 @@ export {
     type SnippetTransformClientOptions,
     type SnippetTransformErrorKind
 } from './snippet-transform-client.ts';
+
 export { compileSnippetTransformFormat } from './snippet-transform-format.ts';
+
 export type {
     SnippetTransformJob,
     SnippetTransformInput,
@@ -15,33 +18,42 @@ export type {
     SnippetTransformCase,
     SnippetTransformFormatNode
 } from './snippet-transform-protocol.ts';
+
 export interface SnippetTransformWorkerEndpoint {
     addEventListener(type: 'message', listener: (event: MessageEvent<SnippetTransformInput>) => void): void;
     removeEventListener(type: 'message', listener: (event: MessageEvent<SnippetTransformInput>) => void): void;
     postMessage(message: SnippetTransformOutput): void;
 }
+
 export function serveSnippetTransforms(endpoint: SnippetTransformWorkerEndpoint): () => void {
     const receive = ({ data: request }: MessageEvent<SnippetTransformInput>): void => {
         const id = request !== null && typeof request === 'object' && Number.isSafeInteger(request.id) && request.id > 0 ? request.id : 0;
+
         try {
             if (id === 0 || request.type !== 'transform') {
                 throw new RangeError('Invalid snippet transform request.');
             }
+
             validateSnippetTransformJobs(request.jobs);
             let remaining = MAX_TRANSFORM_CHARACTERS;
             const budget = createSnippetTransformBudget();
             const patterns = new Map<string, RegExp>();
+
             const values = request.jobs.map((job) => {
                 const key = job.flags + '\0' + job.pattern;
                 let expression = patterns.get(key);
+
                 if (expression === undefined) {
                     expression = new RegExp(job.pattern, job.flags);
                     patterns.set(key, expression);
                 }
+
                 const value = applySnippetTransform(job, remaining, expression, budget);
                 remaining -= value.length;
+
                 return value;
             });
+
             endpoint.postMessage({ type: 'transformed', id: request.id, values });
         } catch (error) {
             endpoint.postMessage({
@@ -52,7 +64,9 @@ export function serveSnippetTransforms(endpoint: SnippetTransformWorkerEndpoint)
             });
         }
     };
+
     endpoint.addEventListener('message', receive);
     endpoint.postMessage({ type: 'ready' });
+
     return () => endpoint.removeEventListener('message', receive);
 }

package/src/snippet-variables.ts

@@ -15,8 +15,11 @@ export function createSnippetResolver(
     const filename = path?.replace(/\\/g, '/').split('/').at(-1);
     const folder = context.folder?.replace(/\\/g, '/').replace(/\/$/, '');
     const normalized = path?.replace(/\\/g, '/');
+
     const pad = (value: number): string => String(value).padStart(2, '0');
+
     const timezone = -now.getTimezoneOffset();
+
     const values: Record<string, string | undefined> = {
         TM_SELECTED_TEXT: context.selectedText,
         TM_CURRENT_LINE: context.currentLine,
@@ -46,16 +49,20 @@ export function createSnippetResolver(
         CURRENT_SECONDS_UNIX: String(Math.floor(now.getTime() / 1000)),
         CURRENT_TIMEZONE_OFFSET: (timezone < 0 ? '-' : '+') + pad(Math.floor(Math.abs(timezone) / 60)) + pad(Math.abs(timezone) % 60)
     };
+
     const builtins = new Map(Object.entries(values));
     const cache = new Map<string, string | undefined>();
+
     return (name) => {
         if (!cache.has(name)) {
             let supplied: string | undefined;
+
             try {
                 supplied = custom?.(name, context);
             } catch {
                 // A failed host override leaves the built-in or editable variable available.
             }
+
             const value =
                 supplied ??
                 (name === 'RANDOM'
@@ -67,8 +74,10 @@ export function createSnippetResolver(
                       : name === 'UUID'
                         ? (sources.uuid?.() ?? globalThis.crypto?.randomUUID())
                         : builtins.get(name));
+
             cache.set(name, value);
         }
+
         return cache.get(name);
     };
 }