From 71e7b215c2f712dcb924439c617c327c0bfce495 Mon Sep 17 00:00:00 2001
From: Anton Tarasov <tarasov.anton1@huawei.com>
Date: Wed, 5 Feb 2025 18:39:04 +0300
Subject: [PATCH 1/2] Add AppStorage for arkts

Signed-off-by: Anton Tarasov <tarasov.anton1@huawei.com>
---
 arkoala/arkui-common/src/arkts/Storage.ts | 358 +++++++++++++++++++++-
 1 file changed, 356 insertions(+), 2 deletions(-)

diff --git a/arkoala/arkui-common/src/arkts/Storage.ts b/arkoala/arkui-common/src/arkts/Storage.ts
index 2d2abe098..41745604a 100644
--- a/arkoala/arkui-common/src/arkts/Storage.ts
+++ b/arkoala/arkui-common/src/arkts/Storage.ts
@@ -13,7 +13,361 @@
  * limitations under the License.
  */
 
-import { GlobalStateManager, mutableState, MutableState } from "@koalaui/runtime"
+import { GlobalStateManager, MutableState, StateManager } from "@koalaui/runtime"
+
+/**
+ * Defines the subscribed abstract property.
+ * @since 7
+ * @systemapi
+ */
+export abstract class SubscribedAbstractProperty<T> {
+    /**
+     * Returns the property name,
+     * e.g. let link = AppStorage.Link("foo") then link.info() == "foo"
+     *
+     * @returns { string } the property name if set or undefined
+     * @syscap SystemCapability.ArkUI.ArkUI.Full
+     * @crossplatform
+     * @since 10
+     */
+    info(): string {
+        return "TODO"
+    }
+    /**
+     * Called when data is obtained.
+     * @since 7
+     * @systemapi
+     */
+    abstract get(): T
+
+    /**
+     * Called when data is created.
+     * @since 7
+     * @systemapi
+     */
+    abstract set(newValue: T): void
+    /**
+     * An app needs to call this function before the instance of SubscribedAbstractProperty
+     * goes out of scope / is subject to garbage collection. Its purpose is to unregister the
+     * variable from the two-way/one-way sync relationship that AppStorage/LocalStorage.link()/prop()
+     * and related functions create.
+     *
+     * @syscap SystemCapability.ArkUI.ArkUI.Full
+     * @crossplatform
+     * @since 10
+     */
+    abstract aboutToBeDeleted(): void
+}
+
+class StorageEntry<T> extends SubscribedAbstractProperty<T> {
+    readonly state: MutableState<T>
+    readonly mutable: boolean
+
+    constructor(state: MutableState<T>, mutable?: boolean) {
+        super()
+        this.state = state
+        this.mutable = mutable ?? true
+    }
+
+    aboutToBeDeleted(): void {
+        // todo
+    }
+
+    get(): T {
+        return this.state.value
+    }
+
+    set(value: T): void {
+        if (this.mutable) this.state.value = value
+    }
+}
+
+export class StorageMap<T> {
+    private static _shared?: object
+    private readonly manager: StateManager = GlobalStateManager.instance
+    private readonly map: Map<string, StorageEntry<T>> = new Map<string, StorageEntry<T>>()
+
+    static shared<T>(): StorageMap<T> {
+        if ((StorageMap._shared as StorageMap<T> | undefined)?.manager != GlobalStateManager.instance) {
+            StorageMap._shared = new StorageMap<T>() // recreate shared storage if state manager is changed
+        }
+        return StorageMap._shared as StorageMap<T>
+    }
+
+    keys(): IterableIterator<string> {
+        return this.map.keys()
+    }
+
+    get size(): number {
+        return this.map.size
+    }
+
+    has(key: string): boolean {
+        return this.map.has(key)
+    }
+
+    entry(key: string): StorageEntry<T> | undefined {
+        return this.map.get(key) as StorageEntry<T> | undefined
+    }
+
+    get(key: string): T | undefined {
+        return this.entry(key)?.get()
+    }
+
+    set(key: string, value: T, create?: boolean, mutable?: boolean): boolean {
+        const entry = this.entry(key)
+        if (entry) {
+            entry.set(value)
+            return true
+        }
+        if (create ?? true) {
+            this.create(key, value, mutable ?? true)
+        }
+        return false
+    }
+
+    link(key: string, value: T): StorageEntry<T> {
+        const entry = this.entry(key)
+        return entry ? entry : this.create(key, value)
+    }
+
+    delete(key: string): boolean {
+        const entry = this.entry(key)
+        if (!entry) return false
+        entry.state.dispose()
+        return this.map.delete(key)
+    }
+
+    clear(): boolean {
+        if (this.map.size == 0) return false
+        for (const entry of this.map.values()) {
+            entry.state.dispose()
+        }
+        this.map.clear()
+        return true
+    }
+
+    private create(key: string, value: T, mutable?: boolean): StorageEntry<T> {
+        const entry = new StorageEntry<T>(this.manager.mutableState<T>(value, true), mutable ?? true)
+        this.map.set(key, entry)
+        return entry
+    }
+}
 
 export class LocalStorage {
-}
\ No newline at end of file
+}
+
+/**
+ * Defines the AppStorage interface.
+ * @since 7
+ */
+export class AppStorage {
+    /**
+     * Called when a link is set.
+     * @since 7
+     * @deprecated since 10
+     */
+    static Link<T>(propName: string): SubscribedAbstractProperty<T> {
+        return AppStorage.link<T>(propName)
+    }
+    /**
+     * Called when a link is set.
+     * @since 10
+     */
+    static link<T>(propName: string): SubscribedAbstractProperty<T> {
+        throw new Error("AppStorage.link is not implemented")
+    }
+
+    /**
+     * Called when a hyperlink is set.
+     * @since 7
+     * @deprecated since 10
+     */
+    static SetAndLink<T>(propName: string, defaultValue: T): SubscribedAbstractProperty<T> {
+        return AppStorage.setAndLink(propName, defaultValue)
+    }
+    /**
+     * Called when a hyperlink is set.
+     * @since 10
+     */
+    static setAndLink<T>(propName: string, defaultValue: T): SubscribedAbstractProperty<T> {
+        throw new Error("AppStorage.setAndLink is not implemented")
+    }
+
+    /**
+     * Called when a property is set.
+     * @since 7
+     * @deprecated since 10
+     */
+    static Prop<T>(propName: string): SubscribedAbstractProperty<T> {
+        return AppStorage.prop<T>(propName)
+    }
+    /**
+     * Called when a property is set.
+     * @since 10
+     */
+    static prop<T>(propName: string): SubscribedAbstractProperty<T> {
+        throw new Error("AppStorage.prop is not implemented")
+    }
+
+    /**
+     * Called when dynamic properties are set.
+     * @since 7
+     * @deprecated since 10
+     */
+    static SetAndProp<S>(propName: string, defaultValue: S): SubscribedAbstractProperty<S> {
+        return AppStorage.setAndProp<S>(propName, defaultValue)
+    }
+    /**
+     * Called when dynamic properties are set.
+     * @since 10
+     */
+    static setAndProp<S>(propName: string, defaultValue: S): SubscribedAbstractProperty<S> {
+        throw new Error("AppStorage.setAndProp is not implemented")
+    }
+
+    /**
+     * Called when owning or not.
+     * @since 7
+     * @deprecated since 10
+     */
+    static Has<T>(propName: string): boolean {
+        return AppStorage.has<T>(propName)
+    }
+    /**
+     * Called when owning or not.
+     * @since 10
+     */
+    static has<T>(propName: string): boolean {
+        return StorageMap.shared<T>().has(propName)
+    }
+
+    /**
+     * Called when data is obtained.
+     * @since 7
+     * @deprecated since 10
+     */
+    static Get<T>(propName: string): T | undefined {
+        return AppStorage.get<T>(propName)
+    }
+    /**
+     * Called when data is obtained.
+     * @since 10
+     */
+    static get<T>(propName: string): T | undefined {
+        return StorageMap.shared<T>().get(propName)
+    }
+
+    /**
+     * Called when setting.
+     * @since 7
+     * @deprecated since 10
+     */
+    static Set<T>(propName: string, newValue: T): boolean {
+        return AppStorage.set(propName, newValue)
+    }
+    /**
+     * Called when setting.
+     * @since 10
+     */
+    static set<T>(propName: string, newValue: T): boolean {
+        return StorageMap.shared<T>().set(propName, newValue, false)
+    }
+
+    /**
+     * Called when setting or creating.
+     * @since 7
+     * @deprecated since 10
+     */
+    static SetOrCreate<T>(propName: string, newValue: T): void {
+        AppStorage.setOrCreate(propName, newValue)
+    }
+    /**
+     * Called when setting or creating.
+     * @since 10
+     */
+    static setOrCreate<T>(propName: string, newValue: T): void {
+        StorageMap.shared<T>().set(propName, newValue, true)
+    }
+
+    /**
+     * Called when a deletion is made.
+     * @since 7
+     * @deprecated since 10
+     */
+    static Delete<T>(propName: string): boolean {
+        return AppStorage.delete<T>(propName)
+    }
+    /**
+     * Called when a deletion is made.
+     * @since 10
+     */
+    static delete<T>(propName: string): boolean {
+        return StorageMap.shared<T>().delete(propName)
+    }
+
+    /**
+     * Called when a dictionary is sorted.
+     * @since 7
+     * @deprecated since 10
+     */
+    static Keys<T>(): IterableIterator<string> {
+        return AppStorage.keys<T>()
+    }
+    /**
+     * Called when a dictionary is sorted.
+     * @since 10
+     */
+    static keys<T>(): IterableIterator<string> {
+        return StorageMap.shared<T>().keys()
+    }
+
+    /**
+     * Called when a cleanup occurs.
+     * @since 7
+     * @deprecated since 9
+     * @useinstead AppStorage.Clear
+     */
+    static staticClear<T>(): boolean {
+        return StorageMap.shared<T>().clear()
+    }
+
+    /**
+     * Called when a cleanup occurs.
+     * @since 9
+     * @deprecated since 10
+     */
+    static Clear<T>(): boolean {
+        return AppStorage.clear<T>()
+    }
+    /**
+     * Called when a cleanup occurs.
+     * @since 10
+     */
+    static clear<T>(): boolean {
+        return StorageMap.shared<T>().clear()
+    }
+
+    /**
+     * Called when the data can be changed.
+     * @since 7
+     */
+    static IsMutable<T>(propName: string): boolean {
+        return StorageMap.shared<T>().entry(propName)?.mutable == true
+    }
+
+    /**
+     * Called when you check how much data is stored.
+     * @since 7
+     */
+    static Size<T>(): number {
+        return AppStorage.size<T>()
+    }
+    /**
+     * Called when you check how much data is stored.
+     * @since 10
+     */
+    static size<T>(): number {
+        return StorageMap.shared<T>().size
+    }
+}
-- 
Gitee


From 21cac6f30ace11e67b2d37126f411061c4f0adc9 Mon Sep 17 00:00:00 2001
From: Anton Tarasov <tarasov.anton1@huawei.com>
Date: Thu, 6 Feb 2025 15:34:52 +0300
Subject: [PATCH 2/2] fix generic typing

Signed-off-by: Anton Tarasov <tarasov.anton1@huawei.com>
---
 arkoala/arkui-common/src/arkts/Storage.ts | 170 ++++++++++++----------
 1 file changed, 95 insertions(+), 75 deletions(-)

diff --git a/arkoala/arkui-common/src/arkts/Storage.ts b/arkoala/arkui-common/src/arkts/Storage.ts
index 41745604a..252904241 100644
--- a/arkoala/arkui-common/src/arkts/Storage.ts
+++ b/arkoala/arkui-common/src/arkts/Storage.ts
@@ -13,7 +13,7 @@
  * limitations under the License.
  */
 
-import { GlobalStateManager, MutableState, StateManager } from "@koalaui/runtime"
+import { Disposable, GlobalStateManager, MutableState, StateManager } from "@koalaui/runtime"
 
 /**
  * Defines the subscribed abstract property.
@@ -59,39 +59,51 @@ export abstract class SubscribedAbstractProperty<T> {
     abstract aboutToBeDeleted(): void
 }
 
-class StorageEntry<T> extends SubscribedAbstractProperty<T> {
-    readonly state: MutableState<T>
+interface Mutable {
+    readonly mutable: boolean
+}
+
+class StorageEntry<V> extends SubscribedAbstractProperty<V> implements Disposable, Mutable {
+    readonly state: MutableState<V>
     readonly mutable: boolean
 
-    constructor(state: MutableState<T>, mutable?: boolean) {
+    constructor(state: MutableState<V>, mutable?: boolean) {
         super()
         this.state = state
         this.mutable = mutable ?? true
     }
 
+    get disposed(): boolean {
+        return this.state.disposed
+    }
+
+    dispose(): void {
+        this.state.dispose()
+    }
+
     aboutToBeDeleted(): void {
         // todo
     }
 
-    get(): T {
+    get(): V {
         return this.state.value
     }
 
-    set(value: T): void {
+    set(value: V): void {
         if (this.mutable) this.state.value = value
     }
 }
 
-export class StorageMap<T> {
-    private static _shared?: object
+export class StorageMap {
+    private static _shared?: StorageMap
     private readonly manager: StateManager = GlobalStateManager.instance
-    private readonly map: Map<string, StorageEntry<T>> = new Map<string, StorageEntry<T>>()
+    private readonly map: Map<string, Object> = new Map<string, Object>()
 
-    static shared<T>(): StorageMap<T> {
-        if ((StorageMap._shared as StorageMap<T> | undefined)?.manager != GlobalStateManager.instance) {
-            StorageMap._shared = new StorageMap<T>() // recreate shared storage if state manager is changed
+    static get shared(): StorageMap {
+        if (StorageMap._shared?.manager != GlobalStateManager.instance) {
+            StorageMap._shared = new StorageMap() // recreate shared storage if state manager is changed
         }
-        return StorageMap._shared as StorageMap<T>
+        return StorageMap._shared as StorageMap
     }
 
     keys(): IterableIterator<string> {
@@ -106,16 +118,21 @@ export class StorageMap<T> {
         return this.map.has(key)
     }
 
-    entry(key: string): StorageEntry<T> | undefined {
-        return this.map.get(key) as StorageEntry<T> | undefined
+    entry<V>(key: string): StorageEntry<V> | undefined {
+        return this.map.get(key) as StorageEntry<V> | undefined
+    }
+
+    entryObject(key: string): Object | undefined {
+        return this.map.get(key)
     }
 
-    get(key: string): T | undefined {
-        return this.entry(key)?.get()
+    get<V>(key: string): V | undefined {
+        const entry = this.entry<V>(key)
+        return entry?.get()
     }
 
-    set(key: string, value: T, create?: boolean, mutable?: boolean): boolean {
-        const entry = this.entry(key)
+    set<V>(key: string, value: V, create?: boolean, mutable?: boolean): boolean {
+        const entry = this.entry<V>(key)
         if (entry) {
             entry.set(value)
             return true
@@ -126,35 +143,37 @@ export class StorageMap<T> {
         return false
     }
 
-    link(key: string, value: T): StorageEntry<T> {
-        const entry = this.entry(key)
+    link<V>(key: string, value: V): StorageEntry<V> {
+        const entry = this.entry<V>(key)
         return entry ? entry : this.create(key, value)
     }
 
     delete(key: string): boolean {
-        const entry = this.entry(key)
-        if (!entry) return false
-        entry.state.dispose()
+        const entry = this.entryObject(key)
+        if (!entry)
+            return false;
+        (entry as Disposable).dispose();
         return this.map.delete(key)
     }
 
     clear(): boolean {
         if (this.map.size == 0) return false
         for (const entry of this.map.values()) {
-            entry.state.dispose()
+            (entry as Disposable).dispose()
         }
         this.map.clear()
         return true
     }
 
-    private create(key: string, value: T, mutable?: boolean): StorageEntry<T> {
-        const entry = new StorageEntry<T>(this.manager.mutableState<T>(value, true), mutable ?? true)
+    private create<V>(key: string, value: V, mutable?: boolean): StorageEntry<V> {
+        const entry = new StorageEntry<V>(this.manager.mutableState<V>(value, true), mutable ?? true)
         this.map.set(key, entry)
         return entry
     }
 }
 
 export class LocalStorage {
+    // todo
 }
 
 /**
@@ -167,14 +186,14 @@ export class AppStorage {
      * @since 7
      * @deprecated since 10
      */
-    static Link<T>(propName: string): SubscribedAbstractProperty<T> {
-        return AppStorage.link<T>(propName)
+    static Link<V>(propName: string): SubscribedAbstractProperty<V> {
+        return AppStorage.link<V>(propName)
     }
     /**
      * Called when a link is set.
      * @since 10
      */
-    static link<T>(propName: string): SubscribedAbstractProperty<T> {
+    static link<V>(propName: string): SubscribedAbstractProperty<V> {
         throw new Error("AppStorage.link is not implemented")
     }
 
@@ -183,14 +202,14 @@ export class AppStorage {
      * @since 7
      * @deprecated since 10
      */
-    static SetAndLink<T>(propName: string, defaultValue: T): SubscribedAbstractProperty<T> {
-        return AppStorage.setAndLink(propName, defaultValue)
+    static SetAndLink<V>(propName: string, defaultValue: V): SubscribedAbstractProperty<V> {
+        return AppStorage.setAndLink<V>(propName, defaultValue)
     }
     /**
      * Called when a hyperlink is set.
      * @since 10
      */
-    static setAndLink<T>(propName: string, defaultValue: T): SubscribedAbstractProperty<T> {
+    static setAndLink<V>(propName: string, defaultValue: V): SubscribedAbstractProperty<V> {
         throw new Error("AppStorage.setAndLink is not implemented")
     }
 
@@ -199,14 +218,14 @@ export class AppStorage {
      * @since 7
      * @deprecated since 10
      */
-    static Prop<T>(propName: string): SubscribedAbstractProperty<T> {
-        return AppStorage.prop<T>(propName)
+    static Prop<V>(propName: string): SubscribedAbstractProperty<V> {
+        return AppStorage.prop<V>(propName)
     }
     /**
      * Called when a property is set.
      * @since 10
      */
-    static prop<T>(propName: string): SubscribedAbstractProperty<T> {
+    static prop<V>(propName: string): SubscribedAbstractProperty<V> {
         throw new Error("AppStorage.prop is not implemented")
     }
 
@@ -215,14 +234,14 @@ export class AppStorage {
      * @since 7
      * @deprecated since 10
      */
-    static SetAndProp<S>(propName: string, defaultValue: S): SubscribedAbstractProperty<S> {
-        return AppStorage.setAndProp<S>(propName, defaultValue)
+    static SetAndProp<V>(propName: string, defaultValue: V): SubscribedAbstractProperty<V> {
+        return AppStorage.setAndProp<V>(propName, defaultValue)
     }
     /**
      * Called when dynamic properties are set.
      * @since 10
      */
-    static setAndProp<S>(propName: string, defaultValue: S): SubscribedAbstractProperty<S> {
+    static setAndProp<V>(propName: string, defaultValue: V): SubscribedAbstractProperty<V> {
         throw new Error("AppStorage.setAndProp is not implemented")
     }
 
@@ -231,15 +250,15 @@ export class AppStorage {
      * @since 7
      * @deprecated since 10
      */
-    static Has<T>(propName: string): boolean {
-        return AppStorage.has<T>(propName)
+    static Has(propName: string): boolean {
+        return AppStorage.has(propName)
     }
     /**
      * Called when owning or not.
      * @since 10
      */
-    static has<T>(propName: string): boolean {
-        return StorageMap.shared<T>().has(propName)
+    static has(propName: string): boolean {
+        return StorageMap.shared.has(propName)
     }
 
     /**
@@ -247,15 +266,15 @@ export class AppStorage {
      * @since 7
      * @deprecated since 10
      */
-    static Get<T>(propName: string): T | undefined {
-        return AppStorage.get<T>(propName)
+    static Get<V>(propName: string): V | undefined {
+        return AppStorage.get<V>(propName)
     }
     /**
      * Called when data is obtained.
      * @since 10
      */
-    static get<T>(propName: string): T | undefined {
-        return StorageMap.shared<T>().get(propName)
+    static get<V>(propName: string): V | undefined {
+        return StorageMap.shared.get<V>(propName)
     }
 
     /**
@@ -263,15 +282,15 @@ export class AppStorage {
      * @since 7
      * @deprecated since 10
      */
-    static Set<T>(propName: string, newValue: T): boolean {
-        return AppStorage.set(propName, newValue)
+    static Set<V>(propName: string, newValue: V): boolean {
+        return AppStorage.set<V>(propName, newValue)
     }
     /**
      * Called when setting.
      * @since 10
      */
-    static set<T>(propName: string, newValue: T): boolean {
-        return StorageMap.shared<T>().set(propName, newValue, false)
+    static set<V>(propName: string, newValue: V): boolean {
+        return StorageMap.shared.set<V>(propName, newValue, false)
     }
 
     /**
@@ -279,15 +298,15 @@ export class AppStorage {
      * @since 7
      * @deprecated since 10
      */
-    static SetOrCreate<T>(propName: string, newValue: T): void {
-        AppStorage.setOrCreate(propName, newValue)
+    static SetOrCreate<V>(propName: string, newValue: V): void {
+        AppStorage.setOrCreate<V>(propName, newValue)
     }
     /**
      * Called when setting or creating.
      * @since 10
      */
-    static setOrCreate<T>(propName: string, newValue: T): void {
-        StorageMap.shared<T>().set(propName, newValue, true)
+    static setOrCreate<V>(propName: string, newValue: V): void {
+        StorageMap.shared.set<V>(propName, newValue, true)
     }
 
     /**
@@ -295,15 +314,15 @@ export class AppStorage {
      * @since 7
      * @deprecated since 10
      */
-    static Delete<T>(propName: string): boolean {
-        return AppStorage.delete<T>(propName)
+    static Delete(propName: string): boolean {
+        return AppStorage.delete(propName)
     }
     /**
      * Called when a deletion is made.
      * @since 10
      */
-    static delete<T>(propName: string): boolean {
-        return StorageMap.shared<T>().delete(propName)
+    static delete(propName: string): boolean {
+        return StorageMap.shared.delete(propName)
     }
 
     /**
@@ -311,15 +330,15 @@ export class AppStorage {
      * @since 7
      * @deprecated since 10
      */
-    static Keys<T>(): IterableIterator<string> {
-        return AppStorage.keys<T>()
+    static Keys(): IterableIterator<string> {
+        return AppStorage.keys()
     }
     /**
      * Called when a dictionary is sorted.
      * @since 10
      */
-    static keys<T>(): IterableIterator<string> {
-        return StorageMap.shared<T>().keys()
+    static keys(): IterableIterator<string> {
+        return StorageMap.shared.keys()
     }
 
     /**
@@ -328,8 +347,8 @@ export class AppStorage {
      * @deprecated since 9
      * @useinstead AppStorage.Clear
      */
-    static staticClear<T>(): boolean {
-        return StorageMap.shared<T>().clear()
+    static staticClear(): boolean {
+        return StorageMap.shared.clear()
     }
 
     /**
@@ -337,37 +356,38 @@ export class AppStorage {
      * @since 9
      * @deprecated since 10
      */
-    static Clear<T>(): boolean {
-        return AppStorage.clear<T>()
+    static Clear(): boolean {
+        return AppStorage.clear()
     }
     /**
      * Called when a cleanup occurs.
      * @since 10
      */
-    static clear<T>(): boolean {
-        return StorageMap.shared<T>().clear()
+    static clear(): boolean {
+        return StorageMap.shared.clear()
     }
 
     /**
      * Called when the data can be changed.
      * @since 7
      */
-    static IsMutable<T>(propName: string): boolean {
-        return StorageMap.shared<T>().entry(propName)?.mutable == true
+    static IsMutable(propName: string): boolean {
+        const entry = StorageMap.shared.entryObject(propName)
+        return entry ? (entry as Mutable).mutable : false
     }
 
     /**
      * Called when you check how much data is stored.
      * @since 7
      */
-    static Size<T>(): number {
-        return AppStorage.size<T>()
+    static Size(): number {
+        return AppStorage.size()
     }
     /**
      * Called when you check how much data is stored.
      * @since 10
      */
-    static size<T>(): number {
-        return StorageMap.shared<T>().size
+    static size(): number {
+        return StorageMap.shared.size
     }
 }
-- 
Gitee