@undefineds.co/xpod 0.3.58 → 0.3.61

package/dist/storage/accessors/MixDataAccessor.d.ts

@@ -1,8 +1,10 @@
 import { Readable } from 'stream';
 import type { Quad } from '@rdfjs/types';
 import { RepresentationMetadata } from '@solid/community-server';
-import type { Representation, ResourceIdentifier, Guarded, DataAccessor } from '@solid/community-server';
-import type { RdfSourceInput } from '../rdf/types';
+import type { Representation, ResourceIdentifier, Guarded, DataAccessor, FileIdentifierMapper } from '@solid/community-server';
+import { type RdfAccessScope } from '../rdf/RdfAccessScope';
+import type { RdfSourceInput, RdfTextChunkInput, RdfTextSourceInput, RdfTermRewriteInput, RdfTermRewriteResult, RdfVectorChunkInput, RdfVectorSourceInput } from '../rdf/types';
+import type { SolidFsChange, SolidFsManifest } from '../../solidfs/types';
 export interface LocalRdfDocument {
     data: Guarded<Readable>;
     metadata: RepresentationMetadata;
@@ -13,6 +15,8 @@ export interface LocalRdfReadableAccessor {
 export interface LocalRdfIndexAccessor {
     syncLocalRdfDocument(identifier: ResourceIdentifier, data?: Guarded<Readable>, contentType?: string, options?: LocalRdfSyncOptions): Promise<void>;
     deleteLocalRdfIndex(identifier: ResourceIdentifier): Promise<void>;
+    moveLocalRdfIndex?(previousIdentifier: ResourceIdentifier, nextIdentifier: ResourceIdentifier, options?: LocalRdfMoveOptions): Promise<number>;
+    rewriteTerms?(input: RdfTermRewriteInput): Promise<RdfTermRewriteResult> | RdfTermRewriteResult;
 }
 export interface LocalRdfSyncOptions {
     source?: string;
@@ -20,9 +24,26 @@ export interface LocalRdfSyncOptions {
     localPath?: string;
     sourceVersion?: string;
 }
+export interface LocalRdfMoveOptions extends LocalRdfSyncOptions {
+    previousSource?: string;
+}
 export interface SourceScopedStructuredRdfAccessor {
     writeRdfSourceDocument(identifier: ResourceIdentifier, quads: Quad[], metadata: RepresentationMetadata, source: RdfSourceInput): Promise<void>;
     deleteRdfSourceDocument(identifier: ResourceIdentifier): Promise<void>;
+    moveRdfSourceDocument?(oldSource: string, next: RdfSourceInput): Promise<number>;
+    indexTextSource?(source: RdfTextSourceInput, text: string, chunks?: RdfTextChunkInput[]): Promise<void>;
+    deleteTextSource?(source: string): Promise<number>;
+    indexVectorSource?(source: RdfVectorSourceInput, chunks: RdfVectorChunkInput[]): Promise<void>;
+    deleteVectorSource?(source: string): Promise<number>;
+}
+export interface LocalRdfAuthorityJournalOperation {
+    id: string;
+}
+export interface LocalRdfAuthorityJournal {
+    recordLocalCommitted(change: SolidFsChange, workspace: SolidFsManifest, txId?: string): Promise<LocalRdfAuthorityJournalOperation>;
+    markDone(id: string): Promise<void>;
+    markRetryableFailure(id: string, error: unknown): Promise<void>;
+    markReconcileRequired(id: string, reason: string): Promise<void>;
 }
 /**
  * MixDataAccessor - Routes data to appropriate storage based on content type
@@ -40,9 +61,12 @@ export declare class MixDataAccessor implements DataAccessor {
     private readonly structuredDataAccessor;
     private readonly unstructuredDataAccessor;
     private readonly rdfFileDataAccessor;
+    private readonly rdfFileMapper?;
+    private readonly localRdfAuthorityJournal?;
     private readonly presignedRedirectEnabled;
     private readonly mirrorContainersToUnstructured;
-    constructor(structuredDataAccessor: DataAccessor, unstructuredDataAccessor: DataAccessor, presignedRedirectEnabled?: boolean, mirrorContainersToUnstructured?: boolean, rdfFileDataAccessor?: DataAccessor);
+    private readonly textSearchIndexingEnabled;
+    constructor(structuredDataAccessor: DataAccessor, unstructuredDataAccessor: DataAccessor, presignedRedirectEnabled?: boolean, mirrorContainersToUnstructured?: boolean, rdfFileDataAccessor?: DataAccessor, textSearchIndexingEnabled?: boolean, rdfFileMapper?: FileIdentifierMapper, localRdfAuthorityJournal?: LocalRdfAuthorityJournal);
     /**
      * This accessor supports all types of data.
      */
@@ -73,7 +97,7 @@ export declare class MixDataAccessor implements DataAccessor {
      * rebuild the structured RDF index. The structured accessor decides whether
      * unsupported shapes have an explicitly configured compatibility path.
      */
-    executeSparqlUpdate(query: string, baseIri?: string): Promise<void>;
+    executeSparqlUpdate(query: string, baseIri?: string, accessScope?: RdfAccessScope): Promise<void>;
     private shouldApplyLocalRdfSparqlUpdate;
     private executeLocalRdfSparqlUpdate;
     private applyLocalRdfDelta;
@@ -99,6 +123,11 @@ export declare class MixDataAccessor implements DataAccessor {
     private readLocalRdfState;
     private writeLocalRdfAuthority;
     private writeLocalRdfAuthorityPatches;
+    private prepareLocalRdfAuthorityJournalPatches;
+    private recordLocalRdfAuthorityJournalPatch;
+    private markLocalRdfAuthorityJournalFailure;
+    private localRdfPatchWorkspace;
+    private localRdfPatchRelativePath;
     private rollbackLocalRdfAuthorityPatches;
     private toDefaultGraphQuad;
     private toGraphQuad;
@@ -112,6 +141,7 @@ export declare class MixDataAccessor implements DataAccessor {
      */
     syncLocalRdfDocument(identifier: ResourceIdentifier, data?: Guarded<Readable>, contentType?: string, options?: LocalRdfSyncOptions): Promise<void>;
     deleteLocalRdfIndex(identifier: ResourceIdentifier): Promise<void>;
+    moveLocalRdfIndex(previousIdentifier: ResourceIdentifier, nextIdentifier: ResourceIdentifier, options?: LocalRdfMoveOptions): Promise<number>;
     private writeRdfDocument;
     private writeStructuredRdfIndex;
     private refreshLocalRdfMirror;
@@ -120,6 +150,8 @@ export declare class MixDataAccessor implements DataAccessor {
     private createLocalRdfMetadata;
     private localRdfContentType;
     private sourceScopedStructuredAccessor;
+    private syncTextSearchIndex;
+    private deleteSearchIndexes;
     private rdfSourceInput;
     private relativePathFromWorkspace;
     private isByLineRdfIdentifier;

package/dist/storage/accessors/MixDataAccessor.js

@@ -4,6 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MixDataAccessor = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_path_1 = __importDefault(require("node:path"));
 const stream_1 = require("stream");
 const global_logger_factory_1 = require("global-logger-factory");
 const arrayify_stream_1 = __importDefault(require("arrayify-stream"));
@@ -14,9 +16,11 @@ const sparqljs_1 = require("sparqljs");
 const community_server_1 = require("@solid/community-server");
 const RdfSparqlAdapter_1 = require("../rdf/RdfSparqlAdapter");
 const RdfContentTypes_1 = require("../rdf/RdfContentTypes");
+const RdfTextProjection_1 = require("../rdf/RdfTextProjection");
 const RdfQuadIndex_1 = require("../rdf/RdfQuadIndex");
 const RdfXmlSerializer_1 = require("../rdf/RdfXmlSerializer");
 const SolidRdfEngine_1 = require("../rdf/SolidRdfEngine");
+const RdfAccessScope_1 = require("../rdf/RdfAccessScope");
 const MetadataRequestContext_1 = require("../MetadataRequestContext");
 /**
  * MixDataAccessor - Routes data to appropriate storage based on content type
@@ -29,14 +33,17 @@ const MetadataRequestContext_1 = require("../MetadataRequestContext");
  * to be used as the RDF storage backend.
  */
 class MixDataAccessor {
-    constructor(structuredDataAccessor, unstructuredDataAccessor, presignedRedirectEnabled = false, mirrorContainersToUnstructured = true, rdfFileDataAccessor = unstructuredDataAccessor) {
+    constructor(structuredDataAccessor, unstructuredDataAccessor, presignedRedirectEnabled = false, mirrorContainersToUnstructured = true, rdfFileDataAccessor = unstructuredDataAccessor, textSearchIndexingEnabled = false, rdfFileMapper, localRdfAuthorityJournal) {
         this.logger = (0, global_logger_factory_1.getLoggerFor)(this);
         this.rdfSparqlAdapter = new RdfSparqlAdapter_1.RdfSparqlAdapter();
         this.structuredDataAccessor = structuredDataAccessor;
         this.unstructuredDataAccessor = unstructuredDataAccessor;
         this.rdfFileDataAccessor = rdfFileDataAccessor;
+        this.rdfFileMapper = rdfFileMapper;
+        this.localRdfAuthorityJournal = localRdfAuthorityJournal;
         this.presignedRedirectEnabled = presignedRedirectEnabled;
         this.mirrorContainersToUnstructured = mirrorContainersToUnstructured;
+        this.textSearchIndexingEnabled = textSearchIndexingEnabled;
     }
     /**
      * This accessor supports all types of data.
@@ -168,6 +175,7 @@ class MixDataAccessor {
         // can operate on real files; remove that mirror together with the index.
         if (this.isLocalMirroredRdf(identifier, metadata)) {
             await this.deleteRdfFileResourceIfPresent(identifier);
+            await this.deleteSearchIndexes(identifier);
         }
         else if (this.isUnstructured(metadata)) {
             await this.deleteUnstructuredResourceIfPresent(identifier);
@@ -183,12 +191,12 @@ class MixDataAccessor {
      * rebuild the structured RDF index. The structured accessor decides whether
      * unsupported shapes have an explicitly configured compatibility path.
      */
-    async executeSparqlUpdate(query, baseIri) {
+    async executeSparqlUpdate(query, baseIri, accessScope) {
         if (baseIri) {
             const identifier = { path: baseIri };
             if (await this.shouldApplyLocalRdfSparqlUpdate(identifier)) {
                 try {
-                    const writtenIdentifiers = await this.executeLocalRdfSparqlUpdate(query, identifier, new Set([identifier.path]));
+                    const writtenIdentifiers = await this.executeLocalRdfSparqlUpdate(query, identifier, new Set([identifier.path]), accessScope);
                     for (const writtenIdentifier of writtenIdentifiers) {
                         this.invalidateMetadataCache(writtenIdentifier);
                     }
@@ -226,7 +234,7 @@ class MixDataAccessor {
             throw error;
         }
     }
-    async executeLocalRdfSparqlUpdate(query, identifier, localRdfAuthorityIris) {
+    async executeLocalRdfSparqlUpdate(query, identifier, localRdfAuthorityIris, accessScope) {
         const parsed = new sparqljs_1.Parser({ baseIRI: identifier.path }).parse(query);
         const delta = this.rdfSparqlAdapter.compileUpdateDelta(parsed, this.parentContainer(identifier).path, {
             defaultGraph: identifier.path,
@@ -234,7 +242,7 @@ class MixDataAccessor {
         const writableGraphIris = this.localRdfDeltaWriteGraphIris(delta.operations, localRdfAuthorityIris);
         const graphStates = await this.loadLocalRdfDeltaGraphs(delta.operations, writableGraphIris, localRdfAuthorityIris);
         const graphQuads = new Map([...graphStates].map(([graphIri, state]) => [graphIri, state.quads]));
-        const nextQuadsByGraph = this.applyLocalRdfDelta(graphQuads, delta.operations, writableGraphIris);
+        const nextQuadsByGraph = this.applyLocalRdfDelta(graphQuads, delta.operations, writableGraphIris, accessScope);
         const patches = writableGraphIris.map((graphIri) => {
             const previous = graphStates.get(graphIri);
             return {
@@ -247,13 +255,15 @@ class MixDataAccessor {
         await this.writeLocalRdfAuthorityPatches(patches);
         return patches.map((patch) => patch.identifier);
     }
-    applyLocalRdfDelta(graphQuads, operations, writableGraphIris) {
+    applyLocalRdfDelta(graphQuads, operations, writableGraphIris, accessScope) {
         const writableGraphs = new Set(writableGraphIris);
         const byGraph = new Map();
         for (const [graphIri, quads] of graphQuads) {
             byGraph.set(graphIri, new Map(quads.map((quad) => [this.quadKey(quad), quad])));
         }
-        const currentQuads = () => [...byGraph.values()].flatMap((quads) => [...quads.values()]);
+        const currentQuads = () => [...byGraph.entries()]
+            .filter(([graphIri]) => !accessScope || (0, RdfAccessScope_1.rdfAccessGraphAllowed)(graphIri, accessScope))
+            .flatMap(([, quads]) => [...quads.values()]);
         const writableQuads = (graphIri) => {
             let quads = byGraph.get(graphIri);
             if (!quads) {
@@ -613,29 +623,100 @@ class MixDataAccessor {
     }
     async writeLocalRdfAuthorityPatches(patches) {
         const applied = [];
+        const journalPatches = [];
+        const journalDrafts = await this.prepareLocalRdfAuthorityJournalPatches(patches);
         try {
-            for (const patch of patches) {
-                let localAuthorityWritten = false;
-                try {
-                    const authorityQuads = patch.nextQuads.map((quad) => this.toDefaultGraphQuad(quad));
-                    await this.writeLocalRdfAuthority(patch.identifier, authorityQuads);
-                    localAuthorityWritten = true;
-                    await this.writeStructuredRdfIndex(patch.identifier, authorityQuads, new community_server_1.RepresentationMetadata(patch.identifier));
-                    applied.push(patch);
-                }
-                catch (error) {
-                    if (localAuthorityWritten) {
-                        applied.push(patch);
-                    }
-                    throw error;
+            for (let index = 0; index < patches.length; index += 1) {
+                const patch = patches[index];
+                const authorityQuads = patch.nextQuads.map((quad) => this.toDefaultGraphQuad(quad));
+                await this.writeLocalRdfAuthority(patch.identifier, authorityQuads);
+                applied.push(patch);
+                const operation = await this.recordLocalRdfAuthorityJournalPatch(journalDrafts[index]);
+                if (operation) {
+                    journalPatches.push({ patch, operation });
                 }
             }
+            for (const patch of applied) {
+                const authorityQuads = patch.nextQuads.map((quad) => this.toDefaultGraphQuad(quad));
+                await this.writeStructuredRdfIndex(patch.identifier, authorityQuads, new community_server_1.RepresentationMetadata(patch.identifier));
+                await this.syncTextSearchIndex(patch.identifier, await this.serializeQuadsForLocalFile(patch.identifier, authorityQuads), {}, authorityQuads);
+            }
+            for (const journalPatch of journalPatches) {
+                await this.localRdfAuthorityJournal?.markDone(journalPatch.operation.id);
+            }
         }
         catch (error) {
+            await this.markLocalRdfAuthorityJournalFailure(journalPatches, error);
             await this.rollbackLocalRdfAuthorityPatches(applied);
             throw error;
         }
     }
+    async prepareLocalRdfAuthorityJournalPatches(patches) {
+        if (!this.localRdfAuthorityJournal || !this.rdfFileMapper || patches.length === 0) {
+            return [];
+        }
+        const mapped = await Promise.all(patches.map(async (patch) => ({
+            patch,
+            link: await this.rdfFileMapper.mapUrlToFilePath(patch.identifier, false, this.localRdfContentType(patch.identifier)),
+        })));
+        const workspace = this.localRdfPatchWorkspace(mapped.map(({ patch }) => patch.identifier.path), mapped.map(({ link }) => link.filePath));
+        const txId = localRdfPatchTxId(workspace, mapped.map(({ patch, link }) => ({
+            path: this.localRdfPatchRelativePath(patch.identifier.path, workspace.workspace, link.filePath, workspace.cwd),
+            resource: patch.identifier.path,
+            sourcePath: link.filePath,
+            type: patch.previousExists ? 'updated' : 'created',
+        })));
+        return mapped.map(({ patch, link }) => ({
+            patch,
+            workspace,
+            txId,
+            change: {
+                path: this.localRdfPatchRelativePath(patch.identifier.path, workspace.workspace, link.filePath, workspace.cwd),
+                resource: patch.identifier.path,
+                source: 'filesystem',
+                sourcePath: link.filePath,
+                contentType: this.localRdfContentType(patch.identifier),
+                projection: 'direct',
+                type: patch.previousExists ? 'updated' : 'created',
+            },
+        }));
+    }
+    async recordLocalRdfAuthorityJournalPatch(draft) {
+        if (!draft || !this.localRdfAuthorityJournal) {
+            return undefined;
+        }
+        return this.localRdfAuthorityJournal.recordLocalCommitted(draft.change, draft.workspace, draft.txId);
+    }
+    async markLocalRdfAuthorityJournalFailure(journalPatches, error) {
+        if (!this.localRdfAuthorityJournal || journalPatches.length === 0) {
+            return;
+        }
+        const message = `Local RDF authority patch did not complete; rollback/reconcile required: ${error instanceof Error ? error.message : String(error)}`;
+        for (const journalPatch of journalPatches) {
+            try {
+                await this.localRdfAuthorityJournal.markRetryableFailure(journalPatch.operation.id, error);
+                await this.localRdfAuthorityJournal.markReconcileRequired(journalPatch.operation.id, message);
+            }
+            catch (journalError) {
+                this.logger.warn(`Failed to update local RDF authority journal for ${journalPatch.patch.identifier.path}: ${journalError instanceof Error ? journalError.message : String(journalError)}`);
+            }
+        }
+    }
+    localRdfPatchWorkspace(resourcePaths, filePaths) {
+        const workspace = commonHttpContainer(resourcePaths) ?? this.parentContainer({ path: resourcePaths[0] }).path;
+        const cwd = commonDirectory(filePaths);
+        return {
+            workspace,
+            cwd,
+            projection: 'direct',
+            entries: [],
+        };
+    }
+    localRdfPatchRelativePath(identifierPath, workspace, filePath, cwd) {
+        const relative = this.relativePathFromWorkspace(identifierPath, workspace)
+            ?? node_path_1.default.relative(cwd, filePath).split(node_path_1.default.sep).join('/');
+        return relative && relative.length > 0 ? relative : node_path_1.default.basename(filePath);
+    }
     async rollbackLocalRdfAuthorityPatches(patches) {
         const failures = [];
         for (const patch of patches.slice().reverse()) {
@@ -644,10 +725,12 @@ class MixDataAccessor {
                     const authorityQuads = patch.previousQuads.map((quad) => this.toDefaultGraphQuad(quad));
                     await this.writeLocalRdfAuthority(patch.identifier, authorityQuads);
                     await this.writeStructuredRdfIndex(patch.identifier, authorityQuads, new community_server_1.RepresentationMetadata(patch.identifier));
+                    await this.syncTextSearchIndex(patch.identifier, await this.serializeQuadsForLocalFile(patch.identifier, authorityQuads), {}, authorityQuads);
                 }
                 else {
                     await this.deleteRdfFileResourceIfPresent(patch.identifier);
                     await this.deleteLocalRdfIndex(patch.identifier);
+                    await this.deleteSearchIndexes(patch.identifier);
                 }
                 this.invalidateMetadataCache(patch.identifier);
             }
@@ -693,6 +776,10 @@ class MixDataAccessor {
             ...options,
             contentType: localContentType,
         });
+        await this.syncTextSearchIndex(identifier, text, {
+            ...options,
+            contentType: localContentType,
+        }, quads);
         this.invalidateMetadataCache(identifier);
     }
     async deleteLocalRdfIndex(identifier) {
@@ -704,6 +791,7 @@ class MixDataAccessor {
             else {
                 await this.structuredDataAccessor.deleteResource(identifier);
             }
+            await this.deleteSearchIndexes(identifier);
             this.invalidateMetadataCache(identifier);
         }
         catch (error) {
@@ -712,18 +800,33 @@ class MixDataAccessor {
             }
         }
     }
+    async moveLocalRdfIndex(previousIdentifier, nextIdentifier, options = {}) {
+        const sourceScopedAccessor = this.sourceScopedStructuredAccessor();
+        if (!sourceScopedAccessor?.moveRdfSourceDocument) {
+            return 0;
+        }
+        const moved = await sourceScopedAccessor.moveRdfSourceDocument(options.previousSource ?? previousIdentifier.path, this.rdfSourceInput(nextIdentifier, options));
+        if (moved > 0) {
+            this.invalidateMetadataCache(previousIdentifier);
+            this.invalidateMetadataCache(nextIdentifier);
+        }
+        return moved;
+    }
     async writeRdfDocument(identifier, data, metadata) {
         const quads = await (0, arrayify_stream_1.default)(data);
         const structuredMetadata = new community_server_1.RepresentationMetadata(metadata);
         (0, community_server_1.addResourceMetadata)(structuredMetadata, false);
         (0, community_server_1.updateModifiedDate)(structuredMetadata);
         await this.ensureRdfFileParentContainers(identifier);
-        await this.rdfFileDataAccessor.writeDocument(identifier, (0, community_server_1.guardStream)(stream_1.Readable.from([await this.serializeQuadsForLocalFile(identifier, quads)])), this.createLocalRdfMetadata(identifier, metadata));
+        const text = await this.serializeQuadsForLocalFile(identifier, quads);
+        await this.rdfFileDataAccessor.writeDocument(identifier, (0, community_server_1.guardStream)(stream_1.Readable.from([text])), this.createLocalRdfMetadata(identifier, metadata));
         try {
             await this.writeStructuredRdfIndex(identifier, quads, structuredMetadata);
+            await this.syncTextSearchIndex(identifier, text, {}, quads);
         }
         catch (error) {
             await this.deleteRdfFileResourceIfPresent(identifier);
+            await this.deleteSearchIndexes(identifier);
             throw error;
         }
     }
@@ -756,7 +859,9 @@ class MixDataAccessor {
             throw error;
         }
         await this.ensureRdfFileParentContainers(identifier);
-        await this.rdfFileDataAccessor.writeDocument(identifier, (0, community_server_1.guardStream)(stream_1.Readable.from([await this.serializeQuadsForLocalFile(identifier, quads)])), this.createLocalRdfMetadata(identifier, metadata));
+        const text = await this.serializeQuadsForLocalFile(identifier, quads);
+        await this.rdfFileDataAccessor.writeDocument(identifier, (0, community_server_1.guardStream)(stream_1.Readable.from([text])), this.createLocalRdfMetadata(identifier, metadata));
+        await this.syncTextSearchIndex(identifier, text, {}, quads);
     }
     async getLocalRdfMetadata(identifier, sourceMetadata) {
         try {
@@ -802,6 +907,24 @@ class MixDataAccessor {
         }
         return undefined;
     }
+    async syncTextSearchIndex(identifier, text, options = {}, quads) {
+        if (!this.textSearchIndexingEnabled || !this.isByLineRdfIdentifier(identifier)) {
+            return;
+        }
+        const accessor = this.sourceScopedStructuredAccessor();
+        if (!accessor?.indexTextSource) {
+            return;
+        }
+        const source = this.rdfSourceInput(identifier, options);
+        await accessor.indexTextSource(source, text, quads ? (0, RdfTextProjection_1.createRdfEntityTextChunks)(source, quads) : undefined);
+    }
+    async deleteSearchIndexes(identifier) {
+        if (!this.textSearchIndexingEnabled || !this.isByLineRdfIdentifier(identifier)) {
+            return;
+        }
+        const accessor = this.sourceScopedStructuredAccessor();
+        await accessor?.deleteTextSource?.(identifier.path);
+    }
     rdfSourceInput(identifier, options) {
         const workspace = options.workspace ?? this.parentContainer(identifier).path;
         return {
@@ -1007,4 +1130,80 @@ class MixDataAccessor {
     }
 }
 exports.MixDataAccessor = MixDataAccessor;
+function localRdfPatchTxId(manifest, changes) {
+    if (changes.length <= 1) {
+        return undefined;
+    }
+    const digest = (0, node_crypto_1.createHash)('sha256')
+        .update(JSON.stringify({
+        workspace: manifest.workspace,
+        projection: manifest.projection,
+        cwd: manifest.cwd,
+        changes,
+        nonce: (0, node_crypto_1.randomUUID)(),
+    }))
+        .digest('hex')
+        .slice(0, 32);
+    return `solidfs_tx_${digest}`;
+}
+function commonHttpContainer(resourcePaths) {
+    const urls = [];
+    for (const resourcePath of resourcePaths) {
+        try {
+            const url = new URL(resourcePath);
+            if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+                return undefined;
+            }
+            url.hash = '';
+            url.search = '';
+            urls.push(url);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (urls.length === 0) {
+        return undefined;
+    }
+    const origin = urls[0].origin;
+    if (!urls.every((url) => url.origin === origin)) {
+        return undefined;
+    }
+    const parentSegments = urls.map((url) => {
+        const parts = url.pathname.replace(/\/+$/u, '').split('/').filter(Boolean);
+        parts.pop();
+        return parts;
+    });
+    const common = [];
+    const first = parentSegments[0];
+    for (let index = 0; index < first.length; index += 1) {
+        const value = first[index];
+        if (!parentSegments.every((segments) => segments[index] === value)) {
+            break;
+        }
+        common.push(value);
+    }
+    const workspace = new URL(urls[0].href);
+    workspace.pathname = `/${common.join('/')}${common.length > 0 ? '/' : ''}`;
+    workspace.hash = '';
+    workspace.search = '';
+    return workspace.href;
+}
+function commonDirectory(filePaths) {
+    if (filePaths.length === 0) {
+        return process.cwd();
+    }
+    const directories = filePaths.map((filePath) => node_path_1.default.resolve(node_path_1.default.dirname(filePath)).split(node_path_1.default.sep));
+    const first = directories[0];
+    const common = [];
+    for (let index = 0; index < first.length; index += 1) {
+        const value = first[index];
+        if (!directories.every((segments) => segments[index] === value)) {
+            break;
+        }
+        common.push(value);
+    }
+    const joined = common.join(node_path_1.default.sep);
+    return joined.length > 0 ? joined : node_path_1.default.parse(node_path_1.default.resolve(filePaths[0])).root;
+}
 //# sourceMappingURL=MixDataAccessor.js.map