Removed JS and sorted README

Author: chrissainty

README.md

@@ -15,49 +15,43 @@ Or via the Visual Studio package manger.
 
 ### Setup
 
-You need to add a reference to the Blazored SessionStorage javascript file in your `index.html` (Blazor WebAssembly) `_Host.cshtml` (Blazor Server).
-
-```html
-<script src="_content/Blazored.SessionStorage/blazored-sessionstorage.js"></script>
-```
-
-You will then need to register the local storage services with the service collection in your _startup.cs_ file.
+You will need to register the session storage services with the service collection in your _startup.cs_ file.
 
 ```c#
 public void ConfigureServices(IServiceCollection services)
 {
-    services.AddBlazoredLocalStorage();
+    services.AddBlazoredSessionStorage();
 }
 ``` 
 
 ### Usage (Blazor WebAssembly)
-To use Blazored.SessionStorage in Blazor WebAssembly, inject the `ILocalStorageService` per the example below.
+To use Blazored.SessionStorage in Blazor WebAssembly, inject the `ISessionStorageService` per the example below.
 
 ```c#
-@inject Blazored.SessionStorage.ILocalStorageService localStorage
+@inject Blazored.SessionStorage.ISessionStorageService sessionStorage
 
 @code {
 
     protected override async Task OnInitializedAsync()
     {
-        await localStorage.SetItemAsync("name", "John Smith");
-        var name = await localStorage.GetItemAsync<string>("name");
+        await sessionStorage.SetItemAsync("name", "John Smith");
+        var name = await sessionStorage.GetItemAsync<string>("name");
     }
 
 }
 ```
 
-With Blazor WebAssembly you also have the option of a synchronous API, if your use case requires it. You can swap the `ILocalStorageService` for `ISyncStorageService` which allows you to avoid use of `async`/`await`. For either interface, the method names are the same.
+With Blazor WebAssembly you also have the option of a synchronous API, if your use case requires it. You can swap the `ISessionStorageService` for `ISyncStorageService` which allows you to avoid use of `async`/`await`. For either interface, the method names are the same.
 
 ```c#
-@inject Blazored.SessionStorage.ISyncStorageService localStorage
+@inject Blazored.SessionStorage.ISyncStorageService sessionStorage
 
 @code {
 
     protected override void OnInitialized()
     {
-        localStorage.SetItem("name", "John Smith");
-        var name = localStorage.GetItem<string>("name");
+        sessionStorage.SetItem("name", "John Smith");
+        var name = sessionStorage.GetItem<string>("name");
     }
 
 }
@@ -68,22 +62,22 @@ With Blazor WebAssembly you also have the option of a synchronous API, if your u
 **NOTE:** Due to pre-rendering in Blazor Server you can't perform any JS interop until the `OnAfterRender` lifecycle method.
 
 ```c#
-@inject Blazored.SessionStorage.ILocalStorageService localStorage
+@inject Blazored.SessionStorage.ISessionStorageService sessionStorage
 
 @functions {
 
     protected override async Task OnAfterRenderAsync()
     {
-        await localStorage.SetItemAsync("name", "John Smith");
-        var name = await localStorage.GetItemAsync<string>("name");
+        await sessionStorage.SetItemAsync("name", "John Smith");
+        var name = await sessionStorage.GetItemAsync<string>("name");
     }
 
 }
 ```
 
 The APIs available are:
 
-- asynchronous via `ILocalStorageService`:
+- asynchronous via `ISessionStorageService`:
   - SetItemAsync()
   - GetItemAsync()
   - RemoveItemAsync()

src/Blazored.SessionStorage/Blazored.SessionStorage.csproj

@@ -7,7 +7,7 @@
     <TypeScriptToolsVersion>3.2</TypeScriptToolsVersion>
 
     <PackageId>Blazored.SessionStorage</PackageId>
-    <Version>1.0.7</Version>
+    <Version>1.0.8</Version>
     <Authors>Chris Sainty</Authors>
     <Description>A library to provide access to session storage in Blazor applications</Description>
     <Copyright>Copyright 2018 (c) Chris Sainty. All rights reserved.</Copyright>

src/Blazored.SessionStorage/SessionStorageService.cs

@@ -26,7 +26,7 @@ public async Task SetItemAsync(string key, object data)
             if (e.Cancel)
                 return;
 
-            await _jSRuntime.InvokeAsync<object>("blazoredSessionStorage.setItem", key, JsonSerializer.Serialize(data));
+            await _jSRuntime.InvokeAsync<object>("sessionStorage.setItem", key, JsonSerializer.Serialize(data));
 
             RaiseOnChanged(key, e.OldValue, data);
         }
@@ -36,7 +36,7 @@ public async Task<T> GetItemAsync<T>(string key)
             if (string.IsNullOrEmpty(key))
                 throw new ArgumentNullException(nameof(key));
 
-            var serialisedData = await _jSRuntime.InvokeAsync<string>("blazoredSessionStorage.getItem", key);
+            var serialisedData = await _jSRuntime.InvokeAsync<string>("sessionStorage.getItem", key);
 
             if (serialisedData == null)
                 return default(T);
@@ -49,14 +49,14 @@ public async Task RemoveItemAsync(string key)
             if (string.IsNullOrEmpty(key))
                 throw new ArgumentNullException(nameof(key));
 
-            await _jSRuntime.InvokeAsync<object>("blazoredSessionStorage.removeItem", key);
+            await _jSRuntime.InvokeAsync<object>("sessionStorage.removeItem", key);
         }
 
-        public async Task ClearAsync() => await _jSRuntime.InvokeAsync<object>("blazoredSessionStorage.clear");
+        public async Task ClearAsync() => await _jSRuntime.InvokeAsync<object>("sessionStorage.clear");
 
-        public async Task<int> LengthAsync() => await _jSRuntime.InvokeAsync<int>("blazoredSessionStorage.length");
+        public async Task<int> LengthAsync() => await _jSRuntime.InvokeAsync<int>("eval", "sessionStorage.length");
 
-        public async Task<string> KeyAsync(int index) => await _jSRuntime.InvokeAsync<string>("blazoredSessionStorage.key", index);
+        public async Task<string> KeyAsync(int index) => await _jSRuntime.InvokeAsync<string>("sessionStorage.key", index);
 
         public void SetItem(string key, object data)
         {
@@ -71,7 +71,7 @@ public void SetItem(string key, object data)
             if (e.Cancel)
                 return;
 
-            _jSInProcessRuntime.Invoke<object>("blazoredSessionStorage.setItem", key, JsonSerializer.Serialize(data));
+            _jSInProcessRuntime.Invoke<object>("sessionStorage.setItem", key, JsonSerializer.Serialize(data));
 
             RaiseOnChanged(key, e.OldValue, data);
         }
@@ -84,7 +84,7 @@ public T GetItem<T>(string key)
             if (_jSInProcessRuntime == null)
                 throw new InvalidOperationException("IJSInProcessRuntime not available");
 
-            var serialisedData = _jSInProcessRuntime.Invoke<string>("blazoredSessionStorage.getItem", key);
+            var serialisedData = _jSInProcessRuntime.Invoke<string>("sessionStorage.getItem", key);
 
             if (serialisedData == null)
                 return default(T);
@@ -100,31 +100,31 @@ public void RemoveItem(string key)
             if (_jSInProcessRuntime == null)
                 throw new InvalidOperationException("IJSInProcessRuntime not available");
 
-            _jSInProcessRuntime.Invoke<object>("blazoredSessionStorage.removeItem", key);
+            _jSInProcessRuntime.Invoke<object>("sessionStorage.removeItem", key);
         }
 
         public void Clear()
         {
             if (_jSInProcessRuntime == null)
                 throw new InvalidOperationException("IJSInProcessRuntime not available");
 
-            _jSInProcessRuntime.Invoke<object>("blazoredSessionStorage.clear");
+            _jSInProcessRuntime.Invoke<object>("sessionStorage.clear");
         }
 
         public int Length()
         {
             if (_jSInProcessRuntime == null)
                 throw new InvalidOperationException("IJSInProcessRuntime not available");
 
-            return _jSInProcessRuntime.Invoke<int>("blazoredSessionStorage.length");
+            return _jSInProcessRuntime.Invoke<int>("eval", "sessionStorage.length");
         }
 
         public string Key(int index)
         {
             if (_jSInProcessRuntime == null)
                 throw new InvalidOperationException("IJSInProcessRuntime not available");
 
-            return _jSInProcessRuntime.Invoke<string>("blazoredSessionStorage.key", index);
+            return _jSInProcessRuntime.Invoke<string>("sessionStorage.key", index);
         }
 
         public event EventHandler<ChangingEventArgs> Changing;