@openhps/rdf 0.1.10 → 0.1.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openhps/rdf",
-  "version": "0.1.10",
+  "version": "0.1.13",
   "description": "Open Hybrid Positioning System",
   "author": "Maxim Van de Wynckel",
   "license": "Apache-2.0",
@@ -41,7 +41,9 @@
   "jsdelivr": "dist/web/openhps-rdf.min.js",
   "files": [
     "dist/**/*",
-    "src/**/*"
+    "src/**/*",
+    "*.js",
+    "*.d.ts"
   ],
   "scripts": {
     "test": "mocha --config test/.mocharc.json",

package/serialization.d.ts

@@ -0,0 +1 @@
+export * from './dist/types/index.serialization';

package/serialization.js

@@ -0,0 +1 @@
+export * from './dist/esm/index.browser';

package/src/rdf/RDFSerializer.ts

@@ -8,7 +8,7 @@ import {
 } from '@openhps/core';
 import { InternalRDFSerializer } from './InternalRDFSerializer';
 import { InternalRDFDeserializer } from './InternalRDFDeserializer';
-import { IriString, Thing } from './types';
+import { IriString, Thing, Subject } from './types';
 import * as N3 from 'n3';
 import { WriterOptions as N3WriterOptions } from 'n3';
 import { namespaces } from '../namespaces';
@@ -112,6 +112,58 @@ export class RDFSerializer extends DataSerializer {
         return this.deserialize(thing);
     }
 
+    static serializeToSubjects<T>(data: T, baseUri?: IriString): Subject[] {
+        const quads: N3.Quad[] = RDFSerializer.serializeToQuads(data, baseUri);
+        const store = new N3.Store(quads);
+        const quadSubjects: N3.Quad_Subject[] = store.getSubjects(null, null, null);
+        /**
+         *
+         * @param quadSubject
+         */
+        function serializePredicates(quadSubject: N3.Quad_Subject) {
+            const quadPredicates: N3.Quad_Predicate[] = store.getPredicates(quadSubject, null, null);
+            return quadPredicates
+                .map((quadPredicate) => {
+                    const quadObjects: N3.Quad_Object[] = store.getObjects(quadSubject, quadPredicate, null);
+                    const literals: Record<string, string[]> = quadObjects
+                        .filter((obj) => obj instanceof N3.Literal)
+                        .filter((obj: N3.Literal) => obj.language === '')
+                        .map((obj: N3.Literal) => ({ [obj.datatype.value]: [obj.value] }))
+                        .reduce((a, b) => ({ ...a, ...b }), {});
+                    const langStrings: Record<string, string[]> = quadObjects
+                        .filter((obj) => obj instanceof N3.Literal)
+                        .filter((obj: N3.Literal) => obj.language !== '')
+                        .map((obj: N3.Literal) => ({ [obj.language]: [obj.value] }))
+                        .reduce((a, b) => ({ ...a, ...b }), {});
+                    const namedNodes: Array<string> = quadObjects
+                        .filter((obj) => obj instanceof N3.NamedNode)
+                        .map((obj) => obj.value);
+                    const blankNodes: Array<any | string> = quadObjects
+                        .filter((obj) => obj instanceof N3.BlankNode)
+                        .map((obj: N3.BlankNode) => serializePredicates(N3.DataFactory.blankNode(obj.value)));
+                    return {
+                        [quadPredicate.value]: {
+                            namedNodes,
+                            blankNodes,
+                            literals,
+                            langStrings,
+                        },
+                    };
+                })
+                .reduce((a, b) => ({ ...a, ...b }), {});
+        }
+        const subjects: Subject[] = quadSubjects
+            .filter((quadSubject) => quadSubject instanceof N3.NamedNode)
+            .map((quadSubject) => {
+                return {
+                    type: 'Subject',
+                    url: quadSubject.value,
+                    predicates: serializePredicates(quadSubject),
+                };
+            });
+        return subjects;
+    }
+
     static serializeToQuads<T>(data: T, baseUri?: IriString): N3.Quad[] {
         const thing =
             (data as any)['predicates'] !== undefined ? (data as unknown as Thing) : this.serialize(data, baseUri);

package/src/rdf/SerializableNamedNode.ts

@@ -1,6 +1,6 @@
 import { SerializableObject } from '@openhps/core';
 import * as N3 from 'n3';
-import { IriString, Thing } from './types';
+import { Thing } from './types';
 
 @SerializableObject({
     rdf: {
@@ -10,12 +10,8 @@ import { IriString, Thing } from './types';
             };
         },
         deserializer: (thing: Thing) => {
-            return new SerializableNamedNode(thing.value as IriString);
+            return new SerializableNamedNode(thing.value);
         },
     },
 })
-export class SerializableNamedNode extends N3.NamedNode {
-    constructor(uri: IriString) {
-        super(uri);
-    }
-}
+export class SerializableNamedNode extends N3.NamedNode {}

package/src/rdf/types.ts

@@ -8,6 +8,19 @@ export type Thing = {
     value: string;
     predicates?: Record<string, (Quad_Object | Thing)[]>;
 };
+export type Subject = {
+    type: 'Subject';
+    url: string;
+    predicates: Record<
+        IriString,
+        Partial<{
+            literals: Record<string, string[]>;
+            langStrings: Record<LocaleString, string[]>;
+            namedNodes: Array<string>;
+            blankNodes: Array<any | string>;
+        }>
+    >;
+};
 export type LocaleString = 'en';
 
 export interface RDFSerializerConfig extends DataSerializerConfig {

package/vocab.d.ts

@@ -0,0 +1 @@
+export * from './dist/types/index.vocab';

package/vocab.js

@@ -0,0 +1 @@
+export * from './dist/esm/index.vocab';

package/webpack.config.js

@@ -0,0 +1,87 @@
+const TerserPlugin = require('terser-webpack-plugin');
+const path = require('path');
+const pkg = require("./package.json");
+
+const LIBRARY_NAME = pkg.name;
+const PROJECT_NAME = pkg.name.replace("@", "").replace("/", "-");
+
+const defaultConfig = env => ({
+  mode: env.prod ? "production" : "development",
+  devtool: 'source-map',
+  resolve: {
+    alias: {
+      typescript: false,
+    },
+    fallback: {
+      path: false,
+      fs: false,
+      os: false,
+      util: false,
+      stream: false,
+      url: false,
+      assert: false,
+      tls: false,
+      net: false,
+      buffer: require.resolve("buffer"),
+    }
+  },
+  optimization: {
+    minimize: env.prod,
+    minimizer: [
+      new TerserPlugin({
+        parallel: true,
+        terserOptions: {
+          keep_classnames: true,
+          sourceMap: true,
+        }
+      })
+    ],
+    portableRecords: true,
+    usedExports: true,
+  },
+  performance: {
+    hints: false,
+    maxEntrypointSize: 300000,
+    maxAssetSize: 300000
+  },
+});
+
+const bundle = (env, module, entry = 'index', suffix = '') => ({
+  name: PROJECT_NAME,
+  entry: `./dist/esm/${entry}.js`,
+  output: {
+    path: path.resolve(__dirname, 'dist'),
+    filename: `web/${PROJECT_NAME}${suffix}${module ? ".es" : ""}${env.prod ? ".min" : ""}.js`,
+    library: module ? undefined : ['OpenHPS', LIBRARY_NAME.substring(LIBRARY_NAME.indexOf("/") + 1)],
+    libraryTarget: module ? "module" : "umd",
+    umdNamedDefine: !module,
+    globalObject: module ? undefined : `(typeof self !== 'undefined' ? self : this)`,
+    environment: { module },
+  },
+  experiments: {
+    outputModule: module,
+  },
+  externalsType: module ? "module" : undefined,
+  externals: {
+    '@openhps/core': module ? "./openhps-core.es" + (env.prod ? ".min" : "") + ".js" : {
+      commonjs: '@openhps/core',
+      commonjs2: '@openhps/core',
+      amd: 'core',
+      root: ['OpenHPS', 'core']
+    }
+  },
+  devtool: 'source-map',
+  plugins: [],
+  ...defaultConfig(env)
+});
+
+module.exports = env => [
+  bundle(env, true, 'index', '.all'),
+  bundle(env, false, 'index', '.all'),
+  bundle(env, true, 'index.sparql', '.sparql'),
+  bundle(env, false, 'index.sparql', '.sparql'),
+  bundle(env, true, 'index.serialization', '.serialization'),
+  bundle(env, false, 'index.serialization', '.serialization'),
+  bundle(env, true, 'index.vocab', '.vocab'),
+  bundle(env, false, 'index.vocab', '.vocab'),
+];