@oslo-flanders/core 1.0.14 → 1.0.16

package/lib/interfaces/AppRunner.d.ts

@@ -13,6 +13,7 @@ export type YargsParams = {
     $0: string;
 };
 export declare abstract class AppRunner<T extends IService, K extends IConfiguration> {
+    protected createYargsInstance(argv: string[]): any;
     runCliSync(process: NodeJS.Process): void;
     abstract runCli(argv: CliArgv): Promise<void>;
     startApp(params: YargsParams, container: Container): Promise<void>;

package/lib/interfaces/AppRunner.js

@@ -1,10 +1,21 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AppRunner = void 0;
 const process_1 = require("process");
 const LogUtil_1 = require("../logging/LogUtil");
 const ServiceIdentifier_1 = require("../ServiceIdentifier");
+const yargs_1 = __importDefault(require("yargs"));
 class AppRunner {
+    createYargsInstance(argv) {
+        return (0, yargs_1.default)(argv)
+            .parserConfiguration({
+            'duplicate-arguments-array': false,
+        })
+            .usage('node ./bin/runner.js [args]');
+    }
     runCliSync(process) {
         this.runCli(process.argv).catch((error) => {
             process_1.stderr.write(error.message);
@@ -16,11 +27,15 @@ class AppRunner {
         const configuration = container.get(ServiceIdentifier_1.ServiceIdentifier.Configuration);
         await configuration.createFromCli(params);
         (0, LogUtil_1.setLoggerFactory)(params);
-        container.bind(ServiceIdentifier_1.ServiceIdentifier.Logger).toDynamicValue(() => (0, LogUtil_1.createLogger)()).inSingletonScope();
+        container
+            .bind(ServiceIdentifier_1.ServiceIdentifier.Logger)
+            .toDynamicValue(() => (0, LogUtil_1.createLogger)())
+            .inSingletonScope();
         const service = container.get(ServiceIdentifier_1.ServiceIdentifier.Service);
-        service.init()
+        service
+            .init()
             .then(() => service.run())
-            .catch(error => console.error(error));
+            .catch((error) => console.error(error));
     }
 }
 exports.AppRunner = AppRunner;

package/lib/store/QuadStore.d.ts

@@ -226,4 +226,16 @@ export declare class QuadStore {
      * @param graph The RDF.Term of the named graph
      */
     getChildAttribute(subject: RDF.Term, graph?: RDF.Term | null): RDF.Term | undefined;
+    /**
+     * Check if class is abstract
+     * @param subject The RDF.Term to determine if it is an abstract class
+     * @param graph The RDF.Term of the named graph
+     */
+    isAbstractClass(subject: RDF.Term, graph?: RDF.Term | null): boolean;
+    /**
+     * Check if class is root object
+     * @param subject The RDF.Term to determine if it is an root object
+     * @param graph The RDF.Term of the named graph
+     */
+    isRootClass(subject: RDF.Term, graph?: RDF.Term | null): boolean;
 }

package/lib/store/QuadStore.js

@@ -389,6 +389,30 @@ let QuadStore = class QuadStore {
     getChildAttribute(subject, graph = null) {
         return (this.findObject(subject, namespaces_1.ns.oslo('childAttribute')));
     }
+    /**
+     * Check if class is abstract
+     * @param subject The RDF.Term to determine if it is an abstract class
+     * @param graph The RDF.Term of the named graph
+     */
+    isAbstractClass(subject, graph = null) {
+        const types = this.findObjects(subject, namespaces_1.ns.rdf('type'));
+        for (const t of types)
+            if (t.value === namespaces_1.ns.oslo('AbstractClass').value)
+                return true;
+        return false;
+    }
+    /**
+     * Check if class is root object
+     * @param subject The RDF.Term to determine if it is an root object
+     * @param graph The RDF.Term of the named graph
+     */
+    isRootClass(subject, graph = null) {
+        const types = this.findObjects(subject, namespaces_1.ns.rdf('type'));
+        for (const t of types)
+            if (t.value === namespaces_1.ns.oslo('RootClass').value)
+                return true;
+        return false;
+    }
 };
 QuadStore = __decorate([
     (0, inversify_1.injectable)(),

package/lib/types/splitUri.d.ts

@@ -0,0 +1,6 @@
+export interface SplittedUri {
+    prefix: string;
+    uri: string;
+    element: string;
+}
+export declare function splitUri(uri: string): Promise<SplittedUri | undefined>;

package/lib/types/splitUri.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitUri = void 0;
+const prefixes_1 = require("../constants/prefixes");
+async function splitUri(uri) {
+    /* Extract prefix and element by finding the last occurrence of # or / */
+    const hashIndex = uri.lastIndexOf('#');
+    const slashIndex = uri.lastIndexOf('/');
+    const splitIndex = Math.max(hashIndex, slashIndex);
+    if (splitIndex > 0) {
+        const prefixUri = uri.slice(0, Math.max(0, splitIndex + 1));
+        const element = uri.replace(prefixUri, '');
+        const prefixes = await (0, prefixes_1.getPrefixes)();
+        let prefixLabel;
+        for (const [label, puri] of Object.entries(prefixes)) {
+            if (puri === prefixUri) {
+                prefixLabel = label;
+                break;
+            }
+        }
+        /* No known prefix found for URI */
+        if (!prefixLabel) {
+            return undefined;
+        }
+        return {
+            prefix: prefixLabel,
+            uri: prefixUri,
+            element,
+        };
+    }
+    /* Splitting failed */
+    return undefined;
+}
+exports.splitUri = splitUri;
+//# sourceMappingURL=splitUri.js.map

package/lib/utils/quadSort.d.ts

@@ -0,0 +1,8 @@
+import type * as RDF from '@rdfjs/types';
+/**
+ * Sort function used on an array of quads. First sorts named nodes alphabetically, then blank nodes alphabetically.
+ * @param quadA An RDF.Quad
+ * @param quadB An RDF.Quad
+ * @returns a number
+ */
+export declare const quadSort: (quadA: RDF.Quad, quadB: RDF.Quad) => number;

package/lib/utils/quadSort.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quadSort = void 0;
+/**
+ * Sort function used on an array of quads. First sorts named nodes alphabetically, then blank nodes alphabetically.
+ * @param quadA An RDF.Quad
+ * @param quadB An RDF.Quad
+ * @returns a number
+ */
+const quadSort = (quadA, quadB) => {
+    if (quadA.subject.termType === quadB.subject.termType) {
+        return quadA.subject.value.localeCompare(quadB.subject.value);
+    }
+    return quadA.subject.termType === 'BlankNode' ? 1 : -1;
+};
+exports.quadSort = quadSort;
+//# sourceMappingURL=quadSort.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oslo-flanders/core",
-  "version": "1.0.14",
+  "version": "1.0.16",
   "description": "Core interfaces and utilities",
   "author": "Digitaal Vlaanderen <https://data.vlaanderen.be/id/organisatie/OVO002949>",
   "homepage": "https://github.com/informatievlaanderen/OSLO-UML-Transformer/tree/main/packages/oslo-core#readme",