@react-native-ohos/react-native-svg 15.0.2-rc.5 → 15.12.1-rc.10

package/harmony/svg/src/main/cpp/utils/SvgMarkerPositionUtils.h

@@ -0,0 +1,200 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#pragma once
+
+#include <cmath>
+#include <vector>
+
+namespace rnoh {
+namespace svg {
+
+constexpr double RNSVG_DEG_TO_RAD = M_PI / 180.0;
+constexpr double RNSVG_RAD_TO_DEG = 180.0 / M_PI;
+constexpr double ANGLE_THRESHOLD = 180.0;
+constexpr double FULL_CIRCLE = 360.0;
+constexpr double BISECT_DIVISOR = 2.0;
+
+enum class RNSVGMarkerType {
+  kStartMarker,
+  kMidMarker,
+  kEndMarker
+};
+
+enum class ElementType {
+  kCGPathElementAddCurveToPoint,
+  kCGPathElementAddQuadCurveToPoint,
+  kCGPathElementMoveToPoint,
+  kCGPathElementAddLineToPoint,
+  kCGPathElementCloseSubpath
+};
+
+class Point {
+public:
+    double x;
+    double y;
+
+public:
+    Point(double x_val, double y_val) : x(x_val), y(y_val) {}
+};
+
+class SegmentData {
+public:
+    Point start_tangent;
+    Point end_tangent;
+    Point position; 
+
+    SegmentData(const Point& _start_tangent, const Point& _end_tangent, const Point& _position)
+        : start_tangent(_start_tangent), end_tangent(_end_tangent), position(_position) {}
+};
+
+class PathElement {
+public:
+    ElementType type;
+    std::vector<Point> points;
+
+public:
+    PathElement(ElementType _type, std::vector<Point> _points)
+        : type(_type), points(_points) {}
+};
+
+class SvgMarkerPosition {
+public:
+    RNSVGMarkerType type;
+    Point origin = {0.0, 0.0};
+    double angle;
+    
+    SvgMarkerPosition(RNSVGMarkerType _type, Point _origin, double _angle): type(_type), origin(_origin), angle(_angle) {}
+};
+
+namespace SvgMarkerPositionUtils{
+    static std::vector<SvgMarkerPosition> positions_;
+    static int element_index_;
+    static Point origin_ = {0, 0};
+    static Point subpath_start_ = {0, 0};
+    static Point in_slope_ = {0, 0};
+    static Point out_slope_ = {0, 0};
+
+    static bool auto_start_reverse_;
+
+    //ios only, use in renderMarker.
+    inline double deg2rad(double deg) {
+        const double RNSVG_degToRad = RNSVG_DEG_TO_RAD;
+        return deg * RNSVG_degToRad;
+    }
+
+    inline double rad2deg(double rad) {
+        const double RNSVG_radToDeg = RNSVG_RAD_TO_DEG;
+        return rad * RNSVG_radToDeg;
+    }
+
+    inline double SlopeAngleRadians(Point p) {
+        return std::atan2(p.y, p.x);
+    }
+
+    inline double BisectingAngle(double in_angle, double out_angle) {
+        if (std::abs(in_angle - out_angle) > ANGLE_THRESHOLD) in_angle += FULL_CIRCLE;
+        return (in_angle + out_angle) / BISECT_DIVISOR;
+    }
+
+    inline Point subtract(Point p1, Point p2) {
+        return {p2.x - p1.x, p2.y - p1.y};
+    }
+
+    inline bool isZero(Point p) {
+        return p.x == 0 && p.y == 0;
+    }
+
+    inline double CurrentAngle(RNSVGMarkerType type) {
+        double in_angle = rad2deg(SlopeAngleRadians(in_slope_));
+        double out_angle = rad2deg(SlopeAngleRadians(out_slope_));
+        switch (type) {
+            case RNSVGMarkerType::kStartMarker:
+                if (auto_start_reverse_) out_angle += ANGLE_THRESHOLD;
+                return out_angle;
+            case RNSVGMarkerType::kMidMarker:
+                return BisectingAngle(in_angle, out_angle);
+            case RNSVGMarkerType::kEndMarker:
+                return in_angle;
+        }
+        return 0;
+    }
+
+    inline void ComputeQuadTangents(SegmentData& data, Point start, Point control, Point end) {
+        data.start_tangent = subtract(control, start);
+        data.end_tangent = subtract(end, control);
+        if (isZero(data.start_tangent)) data.start_tangent = data.end_tangent;
+        else if (isZero(data.end_tangent)) data.end_tangent = data.start_tangent;
+    }
+
+    inline SegmentData ExtractPathElementFeatures(PathElement element) {
+        SegmentData data = {{0,0}, {0,0}, {0,0}};
+        std::vector<Point> points = element.points;
+        switch (element.type) {
+            case ElementType::kCGPathElementAddCurveToPoint:
+                data.position = points[2];
+                data.start_tangent = subtract(points[0], origin_);
+                data.end_tangent = subtract(points[2], points[1]);
+                if (isZero(data.start_tangent)) ComputeQuadTangents(data, points[0], points[1], points[2]);
+                else if (isZero(data.end_tangent)) ComputeQuadTangents(data, origin_, points[0], points[1]);
+                break;
+            case ElementType::kCGPathElementAddQuadCurveToPoint:
+                data.position = points[1];
+                ComputeQuadTangents(data, origin_, points[0], points[1]);
+                break;
+            case ElementType::kCGPathElementMoveToPoint:
+            case ElementType::kCGPathElementAddLineToPoint:
+                data.position = points[0];
+                data.start_tangent = subtract(data.position, origin_);
+                data.end_tangent = subtract(data.position, origin_);
+                break;
+            case ElementType::kCGPathElementCloseSubpath:
+                data.position = subpath_start_;
+                data.start_tangent = subtract(data.position, origin_);
+                data.end_tangent = subtract(data.position, origin_);
+                break;
+        }
+        return data;
+    }
+
+    inline void UpdateFromPathElement(PathElement element) {
+        SegmentData segment_data = ExtractPathElementFeatures(element);
+        out_slope_ = segment_data.start_tangent;
+        if (element_index_ > 0) {
+            RNSVGMarkerType marker_type = element_index_ == 1 ? RNSVGMarkerType::kStartMarker : RNSVGMarkerType::kMidMarker;
+            double angle = CurrentAngle(marker_type);
+            positions_.push_back({marker_type, origin_, angle});
+        }
+        in_slope_ = segment_data.end_tangent;
+        origin_ = segment_data.position;
+        if (element.type == ElementType::kCGPathElementMoveToPoint){
+            subpath_start_ = element.points[0];
+        }else if (element.type == ElementType::kCGPathElementCloseSubpath) {
+            subpath_start_ = {0, 0};
+        }
+        ++element_index_;
+    }
+
+    inline void PathIsDone() {
+        double angle = CurrentAngle(RNSVGMarkerType::kEndMarker);
+        positions_.push_back(SvgMarkerPosition(RNSVGMarkerType::kEndMarker, origin_, angle));
+    }
+
+    inline std::vector<SvgMarkerPosition> fromPath(const std::vector<PathElement>& elements) {
+        positions_.clear();
+        element_index_ = 0;
+        origin_ = {0, 0};
+        subpath_start_ = {0, 0};
+        for (const PathElement& e : elements) {
+            UpdateFromPathElement(e);
+        }
+        PathIsDone();
+        return positions_;
+    }
+}
+
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/src/main/cpp/utils/SvgUtils.h

@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ *
+ * This file incorporates from the OpenHarmony project, licensed under
+ * the Apache License, Version 2.0. Specifically:
+ * - [OpenHarmony/arkui_ace_engine] (https://gitee.com/openharmony/arkui_ace_engine)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy
+ * of the License at:
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ */
+
+#pragma once
+
+#include <chrono>
+#include <cmath>
+#include <cstdint>
+
+#define CHECK_NULL_VOID(ptr)                                                                                           \
+    do {                                                                                                               \
+        if (!(ptr)) {                                                                                                  \
+            return;                                                                                                    \
+        }                                                                                                              \
+    } while (0)
+
+#define CHECK_NULL_RETURN(ptr, ret)                                                                                    \
+    do {                                                                                                               \
+        if (!(ptr)) {                                                                                                  \
+            return ret;                                                                                                \
+        }                                                                                                              \
+    } while (0)
+
+#define CHECK_ERROR_CODE_RETURN(code)                                                                                  \
+    do {                                                                                                               \
+        if ((code) > 0) {                                                                                              \
+            return code;                                                                                               \
+        }                                                                                                              \
+    } while (0)
+
+#define CHECK_EQUAL_VOID(var, value)                                                                                   \
+    do {                                                                                                               \
+        if ((var) == (value)) {                                                                                        \
+            return;                                                                                                    \
+        }                                                                                                              \
+    } while (0)
+
+namespace rnoh {
+namespace svg {
+
+template <typename T, std::size_t N> constexpr std::size_t ArraySize(T (&)[N]) noexcept { return N; }
+
+template <typename T, int32_t N> T ConvertIntToEnum(int32_t index, const T (&values)[N], T defaultValue) {
+    if (index >= 0 && index < N) {
+        return values[index];
+    }
+    return defaultValue;
+}
+
+template <typename T> constexpr T Infinity() { return static_cast<const T>(1000000.0); }
+
+inline bool NearEqual(const double left, const double right, const double epsilon) {
+    return (std::abs(left - right) <= epsilon);
+}
+
+template <typename T> constexpr bool NearEqual(const T &left, const T &right);
+
+template <> inline bool NearEqual<float>(const float &left, const float &right) {
+    constexpr double epsilon = 0.001f;
+    return NearEqual(left, right, epsilon);
+}
+
+template <> inline bool NearEqual<double>(const double &left, const double &right) {
+    constexpr double epsilon = 0.00001f;
+    return NearEqual(left, right, epsilon);
+}
+
+template <typename T> constexpr bool NearEqual(const T &left, const T &right) { return left == right; }
+
+inline bool NearZero(const double value, const double epsilon) { return NearEqual(value, 0.0, epsilon); }
+
+inline bool NearEqual(const double left, const double right) {
+    constexpr double epsilon = 0.001f;
+    return NearEqual(left, right, epsilon);
+}
+
+inline bool NearZero(const double left) {
+    constexpr double epsilon = 0.001f;
+    return NearZero(left, epsilon);
+}
+
+inline bool LessOrEqual(double left, double right) {
+    constexpr double epsilon = 0.001f;
+    return (left - right) < epsilon;
+}
+
+inline bool LessOrEqualCustomPrecision(double left, double right, double epsilon = 0.000001f) {
+    return (left - right) < epsilon;
+}
+
+inline bool LessNotEqual(double left, double right) {
+    constexpr double epsilon = -0.001f;
+    return (left - right) < epsilon;
+}
+
+inline bool LessNotEqualCustomPrecision(double left, double right, double epsilon = -0.000001f) {
+    return (left - right) < epsilon;
+}
+
+inline bool GreatOrEqual(double left, double right) {
+    constexpr double epsilon = -0.001f;
+    return (left - right) > epsilon;
+}
+
+inline bool GreatOrEqualCustomPrecision(double left, double right, double epsilon = -0.000001f) {
+    return (left - right) > epsilon;
+}
+
+inline bool GreatNotEqual(double left, double right) {
+    constexpr double epsilon = 0.001f;
+    return (left - right) > epsilon;
+}
+
+inline bool GreatNotEqualCustomPrecision(double left, double right, double epsilon = 0.000001f) {
+    return (left - right) > epsilon;
+}
+
+inline double Round(double rawNum) {
+    constexpr double epsilon = 0.001f;
+    return std::round(rawNum + epsilon);
+}
+
+inline bool Negative(double value) { return LessNotEqual(value, 0); }
+
+inline bool NonNegative(double value) { return GreatOrEqual(value, 0); }
+
+inline bool Positive(double value) { return GreatNotEqual(value, 0); }
+
+inline bool NonPositive(double value) { return LessOrEqual(value, 0); }
+
+inline bool InRegion(double lowerBound, double upperBound, double destNum) {
+    return LessOrEqual(lowerBound, destNum) && LessOrEqual(destNum, upperBound);
+}
+
+inline bool GreaterOrEqualToInfinity(float num) { return GreatOrEqual(num, Infinity<float>() / 2.0f); }
+
+inline uint64_t GetMilliseconds() {
+    auto now = std::chrono::system_clock::now();
+    auto millisecs = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch());
+    return millisecs.count();
+}
+
+inline uint64_t GetNanoseconds() {
+    auto now = std::chrono::system_clock::now();
+    auto nanoseconds = std::chrono::duration_cast<std::chrono::nanoseconds>(now.time_since_epoch());
+    return nanoseconds.count();
+}
+
+inline float CalculateFriction(float gamma) {
+    constexpr float SCROLL_RATIO = 0.72f;
+    if (GreatOrEqual(gamma, 1.0)) {
+        gamma = 1.0;
+    }
+    return SCROLL_RATIO * static_cast<float>(std::pow(1.0 - gamma, 2));
+}
+
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/src/main/cpp/utils/TextPathHelper.cpp

@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#include "TextPathHelper.h"
+#include <native_drawing/drawing_path.h>
+
+namespace rnoh {
+namespace svg {
+
+namespace {
+constexpr int MSCALE_X = 0; //!< use with getValues/setValues
+constexpr int MSKEW_X = 1;  //!< use with getValues/setValues
+constexpr int MTRANS_X = 2; //!< use with getValues/setValues
+constexpr int MSKEW_Y = 3;  //!< use with getValues/setValues
+constexpr int MSCALE_Y = 4; //!< use with getValues/setValues
+constexpr int MTRANS_Y = 5; //!< use with getValues/setValues
+constexpr int MPERSP_0 = 6; //!< use with getValues/setValues
+constexpr int MPERSP_1 = 7; //!< use with getValues/setValues
+constexpr int MPERSP_2 = 8; //!< use with getValues/setValues
+
+constexpr double tau = 2.0 * M_PI;
+constexpr double radToDeg = 360.0 / tau;
+} // namespace
+
+TextPathHelper::TextPathHelper(const std::shared_ptr<SvgTextPath> &textPath, TextAnchor anchor) {
+    if (!textPath) {
+        return;
+    }
+    path_ = textPath->getTextPath(), sharpMidLine_ = textPath->getMidLine() == TextPathMidLine::sharp;
+    pathLength_ = path_.GetLength(false);
+
+    endOfRendering_ = pathLength_;
+    side_ = textPath->getSide() == TextPathSide::right ? -1 : 1;
+    absoluteStartOffset_ = textPath->getStartOffset();
+    isClosed_ = path_.IsClosed(false); 
+    if (isClosed_) {
+        startOfRendering_ = absoluteStartOffset_ + (anchor == TextAnchor::middle ? -pathLength_ / 2.0 : 0);
+        endOfRendering_ = startOfRendering_ + pathLength_;
+    }
+}
+
+bool TextPathHelper::GetMatrixOnPath(const Params &p, drawing::Matrix &mid) {
+    const double endPoint = p.startPoint + p.charWidth;
+    const double halfWay = p.charWidth / 2;
+    const double midPoint = p.startPoint + halfWay;
+    if (midPoint > endOfRendering_) {
+        return false;
+    } else if (midPoint < startOfRendering_) {
+        return false;
+    }
+    if (sharpMidLine_) {
+        mid = path_.GetMatrix(false, midPoint, GET_POSITION_AND_TANGENT_MATRIX).value_or(drawing::Matrix());
+    } else {
+        drawing::Matrix start;
+        drawing::Matrix end;
+        if (p.startPoint < 0) {
+            start = path_.GetMatrix(false, p.startPoint, GET_POSITION_AND_TANGENT_MATRIX).value_or(drawing::Matrix());
+            start.PreTranslate(p.startPoint, 0);
+        } else {
+            start = path_.GetMatrix(false, p.startPoint, GET_POSITION_MATRIX).value_or(drawing::Matrix());
+        }
+        mid = path_.GetMatrix(true, midPoint, GET_POSITION_MATRIX).value_or(drawing::Matrix());
+
+        if (endPoint > pathLength_) {
+            end = path_.GetMatrix(false, pathLength_, GET_POSITION_AND_TANGENT_MATRIX).value_or(drawing::Matrix());
+            end.PreTranslate((endPoint - pathLength_), 0);
+        } else {
+            end = path_.GetMatrix(false, pathLength_, GET_POSITION_MATRIX).value_or(drawing::Matrix());
+        }
+
+        double startX = start.GetValue(MTRANS_X);
+        double startY = start.GetValue(MTRANS_Y);
+
+        double endX = end.GetValue(MTRANS_X); 
+        double endY = end.GetValue(MTRANS_Y); 
+
+        double lineX = endX - startX;
+        double lineY = endY - startY;
+
+        double glyphMidlineAngle = std::atan2(lineY, lineX);
+        mid.PreRotate((glyphMidlineAngle * radToDeg * side_), 0, 0);
+    }
+
+    mid.PreTranslate(-halfWay, p.dy);
+    mid.PreScale(scaleDirection_, side_, 0, 0);
+    mid.PostTranslate(0, p.y);
+    return true;
+}
+
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/src/main/cpp/utils/TextPathHelper.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#pragma once
+
+#include "drawing/Matrix.h"
+#include "SvgTextPath.h"
+
+namespace rnoh {
+namespace svg {
+
+class TextPathHelper {
+    public:
+    TextPathHelper(const std::shared_ptr<svg::SvgTextPath>& textPath, svg::TextAnchor anchor);
+
+    double GetStartOffset() const {
+        return absoluteStartOffset_;
+    }
+
+    int GetSide() const {
+        return side_;
+    }
+
+    bool Valid() const {
+        return pathLength_ > 0.0;
+    }
+
+    void SetScaleSpacingAndGlyphs(double value) {
+        scaleDirection_ = value * side_;
+    }
+
+    struct Params {
+        double charWidth = 0.0;
+        double startPoint = 0.0;
+        double y = 0.0;
+        double dy = 0.0;
+    };
+    /**
+     * @brief Set transform matrix to paint the character at the given position on the path.
+     *
+     * @return true if this character can be skipped
+     */
+    bool GetMatrixOnPath(const Params& p, drawing::Matrix &mat);
+
+private:
+    drawing::Path path_ = drawing::Path();
+    int side_ = 0;
+    double pathLength_ = 0.0;
+    double startOfRendering_ = 0.0;
+    double endOfRendering_ = 0.0;
+    double absoluteStartOffset_ = 0.0;
+    double scaleDirection_ = 1.0;
+    bool sharpMidLine_ = false;
+    bool isClosed_ = false;
+};
+
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/src/main/ets/RNSVGImageModule.ts

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+import { TurboModule } from "@rnoh/react-native-openharmony/ts";
+
+export class RNSVGImageModule extends TurboModule {
+  public static readonly NAME = 'RNSVGImageModule';
+
+  constructor(ctx: any) {
+    super(ctx);
+    console.log('[kuang] RNSVGImageModule')
+  }
+
+
+  getCacheDir() {
+    return this.ctx.uiAbilityContext.cacheDir;
+  }
+}

package/harmony/svg/src/main/ets/RNSVGRenderableModule.ts

@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+import { TurboModule } from '@rnoh/react-native-openharmony/ts';
+
+export class RNSVGRenderableModule extends TurboModule {
+  public static readonly NAME = 'RNSVGRenderableModule';
+
+  constructor(ctx: any) {
+    super(ctx);
+    console.log('[kuang] RNSVGRenderableModule')
+  }
+}

package/harmony/svg/src/main/ets/RNSVGSvgViewModule.ts

@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+import { TurboModule } from '@rnoh/react-native-openharmony/ts';
+
+export class RNSVGSvgViewModule extends TurboModule {
+  public static readonly NAME = 'RNSVGSvgViewModule';
+
+  constructor(ctx: any) {
+    super(ctx);
+
+
+    console.log('[kuang] RNSVGSvgViewModule')
+  }
+}

package/harmony/svg/src/main/ets/SvgPackage.ts

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+import { RNPackage, TurboModulesFactory } from '@rnoh/react-native-openharmony/ts';
+import type { TurboModule, TurboModuleContext } from '@rnoh/react-native-openharmony/ts';
+import { RNSVGSvgViewModule } from './RNSVGSvgViewModule';
+import { RNSVGRenderableModule } from './RNSVGRenderableModule';
+import { RNSVGImageModule } from './RNSVGImageModule';
+import { hilog } from '@kit.PerformanceAnalysisKit';
+
+class MyLog {
+  static e(logTag: string, content: string) {
+    const maxSize = 1024;
+    if (content.length <= maxSize) {
+      // 长度小于等于限制直接打印
+      hilog.error(0xFF00, logTag, '%{public}s', content);
+    } else {
+      while (content.length > maxSize) {
+        // 循环分段打印
+        let logContent = content.substring(0, maxSize);
+        content = content.replace(logContent, '');
+        hilog.error(0xFF00, logTag, '%{public}s', logContent); // 打印剩余日志
+      }
+    }
+  }
+}
+
+class SvgTurboModulesFactory extends TurboModulesFactory {
+
+  createTurboModule(name: string): TurboModule | null {
+    console.log('[kuang] SvgPackage createTurboModule = ', name)
+
+    if (name === 'RNSVGSvgViewModule') {
+      return new RNSVGSvgViewModule(this.ctx);
+    }
+    if (name === 'RNSVGRenderableModule') {
+      return new RNSVGRenderableModule(this.ctx);
+    }
+    if (name === 'RNSVGImageModule') {
+      return new RNSVGImageModule(this.ctx);
+    }
+    return null;
+  }
+
+  hasTurboModule(name: string): boolean {
+    return name === 'RNSVGSvgViewModule' || name === 'RNSVGRenderableModule' || name === 'RNSVGImageModule';
+  }
+}
+
+export class SvgPackage extends RNPackage {
+  createTurboModulesFactory(ctx: TurboModuleContext): TurboModulesFactory {
+    MyLog.e('[kuang] SvgPackage createTurboModulesFactory = ', JSON.stringify(ctx));
+    return new SvgTurboModulesFactory(ctx);
+  }
+}

package/harmony/svg/src/main/module.json5

@@ -0,0 +1,7 @@
+{
+  module: {
+    name: 'svg',
+    type: 'har',
+    deviceTypes: ['default'],
+  },
+}

package/harmony/svg/src/main/resources/base/element/string.json

@@ -0,0 +1,8 @@
+{
+  "string": [
+    {
+      "name": "page_show",
+      "value": "page from npm package"
+    }
+  ]
+}

package/harmony/svg/src/main/resources/en_US/element/string.json

@@ -0,0 +1,8 @@
+{
+  "string": [
+    {
+      "name": "page_show",
+      "value": "page from npm package"
+    }
+  ]
+}

package/harmony/svg/src/main/resources/zh_CN/element/string.json

@@ -0,0 +1,8 @@
+{
+  "string": [
+    {
+      "name": "page_show",
+      "value": "page from npm package"
+    }
+  ]
+}